selector 0.0.1

data/spec/unit/selector/anything_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Selector
+
+  describe Selector::Anything do
+
+    let(:anything) { described_class.instance }
+
+    describe ".instance" do
+
+      subject { anything }
+
+      it { is_expected.to be_kind_of Condition }
+      it { is_expected.to be_kind_of Singleton }
+      it { is_expected.to be_frozen }
+
+    end # describe .instance
+
+    describe "#[]" do
+
+      subject { anything[:foo] }
+
+      it { is_expected.to eql(true) }
+
+    end # describe #[]
+
+  end # describe Selector::Anything
+
+end # module Selector

data/spec/unit/selector/array_spec.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module Selector
+
+  describe Selector::Array do
+
+    let(:left)  { described_class.new [:foo, :bar] }
+    let(:right) { described_class.new [:bar, :baz] }
+
+    describe ".new" do
+
+      subject { left }
+
+      it { is_expected.to be_kind_of Collection }
+
+      it { is_expected.to be_frozen }
+
+      it "sets the attribute" do
+        expect(subject.attribute).to eql(Set.new [:foo, :bar])
+      end
+
+    end # describe .new
+
+    describe "#&" do
+
+      subject { left & right }
+
+      context "array" do
+
+        it "returns the array" do
+          expect(subject).to be_kind_of described_class
+        end
+
+        it "composes the attributes" do
+          expect(subject.attribute).to eql(Set.new [:bar])
+        end
+
+      end # context
+
+      context "non-array" do
+
+        let(:right) { Condition.new }
+        it { is_expected.to be_kind_of(And) }
+
+      end # context
+
+    end # describe #&
+
+    describe "#|" do
+
+      subject { left | right }
+
+      context "array" do
+
+        it "returns the array" do
+          expect(subject).to be_kind_of described_class
+        end
+
+        it "composes the attributes" do
+          expect(subject.attribute).to eql(Set.new [:foo, :bar, :baz])
+        end
+
+      end # context
+
+      context "non-array" do
+
+        let(:right) { Condition.new }
+        it { is_expected.to be_kind_of(Or) }
+
+      end # context
+
+    end # describe #&
+
+  end # describe Selector::Array
+
+end # module Selector

data/spec/unit/selector/collection_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Selector
+
+  describe Selector::Collection do
+
+    let(:collection) { described_class.new set }
+    let(:set)        { Set.new [:foo, :bar]    }
+
+    describe ".new" do
+
+      subject { collection }
+
+      it { is_expected.to be_kind_of Condition }
+      it { is_expected.to be_frozen }
+
+      it "requires exactly 1 argument" do
+        expect(collection.attribute).to eql(set)
+        expect { described_class.new }.to raise_error ArgumentError
+        expect { described_class.new [:foo], [:bar] }
+          .to raise_error ArgumentError
+      end
+
+    end # describe .new
+
+    describe "#[]" do
+
+      subject { collection[value] }
+
+      context "existing value" do
+
+        let(:value) { :foo }
+        it { is_expected.to eql(true) }
+
+      end # context
+
+      context "absent value" do
+
+        let(:value) { :baz }
+        it { is_expected.to eql(false) }
+
+      end # context
+
+    end # describe #[]
+
+  end # describe Selector::Collection
+
+end # module Selector

data/spec/unit/selector/condition_spec.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+
+module Selector
+
+  describe Selector::Condition do
+
+    let(:test_klass) { Class.new(described_class)           }
+    let(:attributes) { 2.times.map { double(freeze: true) } }
+    let(:condition)  { test_klass.new(*attributes)          }
+    let(:other)      { test_klass.new                       }
+
+    describe ".new" do
+
+      subject { condition }
+
+      it { is_expected.to be_kind_of Comparable }
+      it { is_expected.to be_frozen }
+
+      it "doesn't freeze attributes" do
+        expect { subject }.not_to change { attributes.frozen? }
+      end
+
+    end # describe .new
+
+    describe "#attributes" do
+
+      subject { condition.attributes }
+
+      it { is_expected.to eql attributes }
+      it { is_expected.to be_frozen }
+
+      context "by default" do
+
+        let(:condition) { test_klass.new }
+        it { is_expected.to eql [] }
+
+      end # context
+
+    end # describe #attributes
+
+    describe "#attribute" do
+
+      subject { condition.attribute }
+      it { is_expected.to eql attributes.first }
+
+    end # describe #attribute
+
+    describe "#==" do
+
+      subject { condition == other }
+
+      let(:other) { test_klass.new(*attributes) }
+
+      context "with the same type and attributes" do
+
+        it { is_expected.to eql(true) }
+
+      end # context
+
+      context "with other attributes" do
+
+        let(:other) { test_klass.new }
+        it { is_expected.to eql(false) }
+
+      end # context
+
+      context "with another type" do
+
+        let(:other) { described_class.new(*attributes) }
+        it { is_expected.to eql(false) }
+
+      end # context
+
+    end # describe #==
+
+    describe "#[]" do
+
+      subject { condition[:foo] }
+
+      it "should be implemented" do
+        expect { subject }.to raise_error do |error|
+          expect(error).to be_kind_of NotImplementedError
+          expect(error.message).to eql "#{test_klass}#[] not implemented"
+        end
+      end
+
+    end # describe #[]
+
+    describe "#!" do
+
+      subject { !condition }
+
+      it "returns the inversion" do
+        expect(subject).to be_kind_of Not
+        expect(subject.attributes).to eql [condition]
+      end
+
+    end # describe #!
+
+    describe "#&" do
+
+      subject { condition & other }
+
+      it "creates composition" do
+        expect(subject).to be_kind_of(And)
+        expect(subject.attributes).to contain_exactly(condition, other)
+      end
+
+    end # describe #&
+
+    describe "#-" do
+
+      subject { condition - other }
+
+      it "creates composition" do
+        expect(subject).to be_kind_of(And)
+        expect(subject.attributes).to contain_exactly(condition, !other)
+      end
+
+    end # describe #
+
+    describe "#|" do
+
+      subject { condition | other }
+
+      it "creates composition" do
+        expect(subject).to be_kind_of(Or)
+        expect(subject.attributes).to contain_exactly(condition, other)
+      end
+
+    end # describe #|
+
+  end # describe Selector::Condition
+
+end # module Selector

data/spec/unit/selector/function_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module Selector
+
+  describe Selector::Function do
+
+    let(:function) { described_class.new -> v { v[/foo/] } }
+
+    describe ".new" do
+
+      subject { function }
+
+      it { is_expected.to be_kind_of Condition }
+      it { is_expected.to be_frozen }
+
+      it "requires exactly 1 argument" do
+        expect { described_class.new }.to raise_error ArgumentError
+        expect { described_class.new [:foo], [:bar] }
+          .to raise_error ArgumentError
+      end
+
+    end # describe .new
+
+    describe "#[]" do
+
+      subject { function[value] }
+
+      context "existing value" do
+
+        let(:value) { :foo }
+        it { is_expected.to eql(true) }
+
+      end # context
+
+      context "absent value" do
+
+        let(:value) { :baz }
+        it { is_expected.to eql(false) }
+
+      end # context
+
+    end # describe #[]
+
+  end # describe Selector::Function
+
+end # module Selector

data/spec/unit/selector/not_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Selector
+
+  describe Selector::Not do
+
+    let(:inversion) { described_class.new condition }
+    let(:condition) do
+      result = double freeze: true
+      allow(result).to receive(:[]) { |value| value == :foo }
+      result
+    end
+
+    describe ".new" do
+
+      subject { inversion }
+
+      it { is_expected.to be_kind_of Condition }
+      it { is_expected.to be_frozen }
+
+      context "ANYTHING" do
+
+        let(:condition) { ANYTHING }
+        it { is_expected.to eql NOTHING }
+
+      end # context
+
+      context "NOTHING" do
+
+        let(:condition) { NOTHING }
+        it { is_expected.to eql ANYTHING }
+
+      end # context
+
+      context "other" do
+
+        it { is_expected.to be_kind_of described_class }
+
+      end # context
+
+    end # describe .new
+
+    describe "#[]" do
+
+      it "inverts the condition" do
+        expect(inversion[:foo]).to eql(false)
+        expect(inversion[:bar]).to eql(true)
+      end
+
+    end # describe #[]
+
+    describe "#!" do
+
+      subject { !inversion }
+      it { is_expected.to equal condition }
+
+    end # describe #!
+
+  end # describe Selector::Not
+
+end # module Selector

data/spec/unit/selector/nothing_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Selector
+
+  describe Selector::Nothing do
+
+    let(:nothing) { described_class.instance }
+
+    describe ".instance" do
+
+      subject { nothing }
+
+      it { is_expected.to be_kind_of Condition }
+      it { is_expected.to be_kind_of Singleton }
+      it { is_expected.to be_frozen }
+
+    end # describe .instance
+
+    describe "#[]" do
+
+      subject { nothing[:foo] }
+
+      it { is_expected.to eql(false) }
+
+    end # describe #[]
+
+  end # describe Selector::Nothing
+
+end # module Selector

data/spec/unit/selector/or_spec.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+require "shared/generator"
+
+module Selector
+
+  describe Selector::Or do
+
+    let(:foo) { generate(/foo/) }
+    let(:bar) { generate(/bar/) }
+    let(:baz) { generate(/baz/) }
+
+    let(:composition) { described_class.new(foo, bar) }
+
+    describe ".new" do
+
+      subject { composition }
+
+      it { is_expected.to be_kind_of Condition }
+      it { is_expected.to be_frozen }
+
+      it "returns NOTHING when possible" do
+        subject = described_class.new NOTHING
+        expect(subject).to eql NOTHING
+      end
+
+      it "returns ANYTHING if exists" do
+        subject = described_class.new foo, bar, ANYTHING
+        expect(subject).to eql ANYTHING
+      end
+
+      it "returns ANYTHING when possible" do
+        subject = described_class.new foo, !foo
+        expect(subject).to eql ANYTHING
+      end
+
+      it "returns the only attribute" do
+        subject = described_class.new foo, NOTHING
+        expect(subject).to eql foo
+      end
+
+      it "ignores duplication" do
+        subject = described_class.new foo, bar, foo
+        expect(subject.attributes).to eql [foo, bar]
+      end
+
+      it "ignores NOTHING" do
+        subject = described_class.new foo, bar, NOTHING
+        expect(subject.attributes).to eql [foo, bar]
+      end
+
+    end # describe .new
+
+    describe "#[]" do
+
+      subject { composition[value] }
+
+      context "when any of the conditions is satisfied" do
+
+        let(:value) { "foo" }
+        it { is_expected.to eql(true) }
+
+      end # context
+
+      context "when all conditions aren't satisfied" do
+
+        let(:value) { "baz" }
+        it { is_expected.to eql(false) }
+
+      end # context
+
+    end # describe #[]
+
+    describe "#|" do
+
+      subject { composition | baz }
+
+      it { is_expected.to be_kind_of(described_class) }
+
+      it "updates conditions (avoids nesting)" do
+        expect(subject.attributes).to eql [foo, bar, baz]
+      end
+
+    end # describe #|
+
+  end # describe Selector::Or
+
+end # module Selector