import scrapy

class BlogSpider(scrapy.Spider):
    name = 'blogspider'
    start_urls = ['https://www.zyte.com/blog/']

    def parse(self, response):
        for title in response.css('.oxy-post-title'):
            yield {'title': title.css('::text').get()}

        for next_page in response.css('a.next'):
            yield response.follow(next_page, self.parse)

def css(self, *a, **kw):
    """Shortcut method implemented onlyby responses whose content
    is text (subclasses of TextResponse).
    """
    raise NotSupported("Response contentisn't text")

def css(self, query):
    return self.selector.css(query)

@property
    def selector(self):
        from scrapy.selector import Selector
        if self._cached_selector is None:
            self._cached_selector = Selector(self)
        return self._cached_selector

from scrapy.selector.unified import Selector, SelectorList

class Selector(_ParselSelector, object_ref):

from parsel import Selector as _ParselSelector

"""简单文法推导 & 二义性检查器

文法:
S -> iS | M
M -> iMeS | O
-----
记号:
S = statement, M = matched_statement, O = other
i = if, e = else
"""

import copy

class Obj:
    """储存推导路径的定制对象

    Attributes:
        value: 当前值
        path: 推导路径
    """

    def __init__(self, init):
        self.value = init # 当前值
        self.path = []    # 推导路径

        self.path.append(init)

    def push(self, ns):
        """推导

        指定推导并加入推导路径

        Args:
            ns: 新推导出的短语
        """
        self.value = ns
        self.path.append(ns)

    def __repr__(self):
        return self.value

    # 重载相等性判断
    def __hash__(self):
        return hash(self.value)

    def __eq__(self, other):
        return self.value == other.value

# 推导用到的结构
cur = [Obj('S')] # 当前值 | 初始值
nxt = []         # 被推导出的临时值

# 所有推导结果
# 用来检查二义性
ahs = set()
ahl = []

# 检查二义性检查有效
assert(Obj('SS') == Obj('SS'))
assert(Obj('SS') != Obj('SSb'))

def cfind(s : str):
    """查找文法变量(非终结符)
    """
    spos = s.find('S')
    mpos = s.find('M')

    if spos == -1 and mpos == -1:
        return 'O'

    if spos == -1:
        return 'M'
    if mpos == -1:
        return 'S'

    if spos < mpos:
        return 'S'
    else:
        return 'M'

# main -------------------------------------------------------------------------

for i in range(100):
    # 推导
    for mem in cur:
        svar = cfind(mem.value)
        if svar == 'S':
            # 1
            prod1 = copy.deepcopy(mem)
            prod1.push(prod1.value.replace('S', 'iS', 1))
            nxt.append(prod1)
            # 2
            prod2 = copy.deepcopy(mem)
            prod2.push(prod2.value.replace('S', 'M', 1))
            nxt.append(prod2)
        elif svar == 'M':
            # 1
            prod1 = copy.deepcopy(mem)
            prod1.push(prod1.value.replace('M', 'iMeS', 1))
            nxt.append(prod1)
            # 2
            prod2 = copy.deepcopy(mem)
            prod2.push(prod2.value.replace('M', 'O', 1))
            nxt.append(prod2)

    ahl.extend(nxt) # 推导出的 nxt 加入 all history list

    # 查找二义性冲突 并更新 set
    for nmem in nxt:

        # 在 all history set 中查找相同的推导结果
        # 如果找到二义结果才执行整个 if
        if nmem in ahs:
            # 在 ahl 里找所有重复推出的短语
            # NOFIXME: 是不是应该先找在把 nxt 加入 ahl，不然如果列表顺序乱了不就输出两个一毛一样的
            # FIXNMB: 这里是打印所有的重复项
            for s in ahl:
                if s == nmem:
                    print(s.path) # 打印重复项

        ahs.add(nmem)
    
    # 交互式控制一轮轮推导
    print(i+1)
    input('next>')
    cur = nxt
    nxt = []