// test文件中调用方法，给一个Set x:y和现有的标签"x=y"进行匹配，显然可以看出，匹配成功
expectMatch(t, "x=y", Set{"x": "y"})


// ls Set是匹配目标，selector是现有标签
func expectMatch(t *testing.T, selector string, ls Set) {
  // 这里将selector x=y解析成Selector，解析Parse的实现在下一篇文章讲，Selector会在后文讲。
	lq, err := Parse(selector)
	if err != nil {
		t.Errorf("Unable to parse %v as a selector\n", selector)
		return
	}
  // Selector有一个方法matches，进行匹配
	if !lq.Matches(ls) {
		t.Errorf("Wanted %s to match '%s', but it did not.\n", selector, ls)
	}
}

// labels.go

// Labels allows you to present labels independently from their storage.
type Labels interface {
	Has(label string) (exists bool)

	Get(label string) (value string)
}

type Set map[string]string

// .. 省略Set的接口实现

// selector.go
// Selector represents a label selector.
type Selector interface {
	Matches(Labels) bool

	Empty() bool

	String() string

	Add(r ...Requirement) Selector

	// ... 省略了一些方法
}

// selector.go

// Requirement是对标签匹配的一个抽象。在internalSelector进行匹配的时候，会遍历所有的Requirement，将目标label和每一个Requirement进行Match匹配。
type Requirement struct {
  // 键
	key      string
  
 	// == != exists等运算符
	operator selection.Operator
  // 值
	strValues []string
}

// internalSelector是默认的Selector，实现and运算，即要满足每一个Reqirement的匹配。有一个匹配失败，则整体匹配失败。
type internalSelector []Requirement

func (s internalSelector) Matches(l Labels) bool {
	for ix := range s {
		if matches := s[ix].Matches(l); !matches {
			return false
		}
	}
	return true
}

func NewSelector() Selector {
	return internalSelector(nil)
}

// 这里根据每一种运算类型，分别进行匹配，调用了Labels的has方法，Labels接口在上文有提到。
func (r *Requirement) Matches(ls Labels) bool {
	switch r.operator {
	case selection.In, selection.Equals, selection.DoubleEquals:
		if !ls.Has(r.key) {
			return false
		}
		return r.hasValue(ls.Get(r.key))
	case selection.NotIn, selection.NotEquals:
		if !ls.Has(r.key) {
			return true
		}
		return !r.hasValue(ls.Get(r.key))
	case selection.Exists:
		return ls.Has(r.key)

  // ... 省略一些case
    
	default:
		return false
	}
}