# scrapy 中初始化rule规则
class Rule(object):

    # link_extractor 链接提取器，
    # def link_extractor(self, allow=(), deny=(), allow_domains=(), deny_domains=(), restrict_xpaths=(), tags=('a', 'area'), attrs=('href',), canonicalize=False,  unique=True, process_value=None, deny_extensions=None, restrict_css=(), strip=True)
    # allow 链接提取规格 满足的链接将会被提取 没有默认匹配全部 （单个正则表达式或正则表达式的列表）
    # deny  链接提取规格 满足的链接将不会被提取 没有默认匹配全部 （单个正则表达式或正则表达式的列表）
    # allow_domains 定义提取的域范围 （单个字符串或者类别）
    # deny_domains 定义不提取的域范围 （单个字符串或者类别）
    # deny_extensions 需要忽略的url扩展名列表
    # restrict_xpaths （一个xpath或者xpath列表）链接将会从xpath提取的范围内提取链接
    # restrict_css （一个css或者css列表）链接将会从css提取的范围内提取链接
    # tags 提取链接的标签列表
    # attrs 提取标签对应的属性
    # canonicalize 规范提取链接，让提取链接按照一定规则，方便去重
    # http: // www.example.com / path / xxx?name = leyle & passwd = leyle
    # http: // www.example.com / path / xxx?passwd = leyle & name = leyle
    # unique 提取的链接是否去重
    # process_value 扫描提取出的每个标签的属性和值，替换其值。 str.replace()
    # callback 回调函数 接受response 返回items
    # cb_kwargs 传给回调函数的参数，字典
    # follow 设置提取的链接是否跟进
    # process_links 指定回调函数，处理link_extractor提取出来的链接
    # process_request 指定回调函数，处理request对象(priority设置url请求优先级)
    def __init__(self, link_extractor, callback=None, cb_kwargs=None, follow=None, process_links=None,
                 process_request=identity):
        self.link_extractor = link_extractor
        self.callback = callback
        # 如果cb_kwargs为none self。cb_kwargs={}
        self.cb_kwargs = cb_kwargs or {}
        self.process_links = process_links
        self.process_request = process_request
        if follow is None:
            # follow默认为True
            self.follow = False if callback else True
        else:
            self.follow = follow


class CrawlSpider(Spider):
    # 定义rules一个元组
    # 元组在初始化的时候被创建，创建之后就不能被修改。
    rules = ()

    def __init__(self, *a, **kw):
        # super 在继承父方法的基础上重写该方法
        super(CrawlSpider, self).__init__(*a, **kw)
        # 调用_compile_rules()方法
        self._compile_rules()

    # 调用parse()处理start_urls中返回的response对象
    # parse()则将这些response对象传递给了_parse_response()函数处理，并设置回调函数为parse_start_url()
    # 设置了跟进标志位True
    # parse将返回item和跟进了的Request对象
    def parse(self, response):
        return self._parse_response(response, self.parse_start_url, cb_kwargs={}, follow=True)

    # 处理start_url中返回的response，需要重写
    def parse_start_url(self, response):
        return []

    def process_results(self, response, results):
        return results

    # 从response中抽取符合任一用户定义'规则'的链接，并构造成Resquest对象返回
    def _requests_to_follow(self, response):
        # 判断response是否是htmlresponse类型
        if not isinstance(response, HtmlResponse):
            return
        # 创建一个集合,保证跟踪的链接不重复
        # hash计算，跟每个hash值进行比较，判断是否重复
        seen = set()
        # 抽取之内的所有链接，只要通过任意一个'规则'，即表示合法
        # enumerate枚举
        for n, rule in enumerate(self._rules):
            # rule.link_extractor.extract_links(response)内部方法，返回link数据
            # 提取需要跟进的链接
            links = [l for l in rule.link_extractor.extract_links(response) if l not in seen]

            # 将链接加入seen集合，为每个链接生成Request对象，并设置回调函数为_repsonse_downloaded()
            for link in links:
                # 加入到集合里面
                seen.add(link)
                # 构造Request对象，并将Rule规则中定义的回调函数作为这个Request对象的回调函数
                r = Request(url=link.url, callback=self._response_downloaded)
                # 传递参数到回调函数
                r.meta.update(rule=n, link_text=link.text)
                # 对每个Request调用process_request()函数，返回request   默认是原样返回
                yield rule.process_request(r)

    # 处理通过rule提取出的连接，并返回item以及request
    def _response_downloaded(self, response):
        # 根据rule规则提取链接
        rule = self._rules[response.meta['rule']]
        # 调用_parse_response方法
        return self._parse_response(response, rule.callback, rule.cb_kwargs, rule.follow)

    # 解析response对象，会用callback解析处理他，并返回request或Item对象
    def _parse_response(self, response, callback, cb_kwargs, follow=True):
        # 首先判断是否设置了回调函数。（该回调函数可能是rule中的解析函数，也可能是 parse_start_url函数）
        # 如果设置了回调函数（parse_start_url()），那么首先用parse_start_url()处理response对象，
        # 然后再交给process_results处理。返回cb_res的一个列表
        if callback:
            # 如果是parse调用的，则会解析成Request对象
            # 如果是rule callback，则会解析成Item
            cb_res = callback(response, **cb_kwargs) or ()
            cb_res = self.process_results(response, cb_res)
            # iterate_spider_output 内部方法 根据cb_res类型返回不同类型的数据
            for requests_or_item in iterate_spider_output(cb_res):
                yield requests_or_item

        # 如果需要跟进，那么使用定义的Rule规则提取并返回这些Request对象
        if follow:
            # 返回每个Request对象
            for request_or_item in self._requests_to_follow(response):
                yield request_or_item

    def _compile_rules(self):
        def get_method(method):
            # callable 判断对象是否可以调用
            if callable(method):
                return method
            # isinstance判断对象是否是这里类型
            # six.string_types是内部定义的类型 str
            elif isinstance(method, six.string_types):
                # 返回method对象的属性，就返回默认值
                return getattr(self, method, None)

        # rules 浅拷贝一份出来
        self._rules = [copy.copy(r) for r in self.rules]
        # 循环出每个rule对象
        for rule in self._rules:
            # 获取callback属性
            rule.callback = get_method(rule.callback)
            # 获取process_links属性
            rule.process_links = get_method(rule.process_links)
            # 获取process_request属性
            rule.process_request = get_method(rule.process_request)