selector 0.0.1

data/lib/selector/function.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Selector
+
+  # The condition checks if the function returns truthy result for a value
+  #
+  # @example (see #[])
+  #
+  class Function < Condition
+
+    # Initializes the condition with a function
+    #
+    # @param [#call] function
+    #
+    def initialize(_)
+      super
+    end
+
+    # Checks if the function returns truthy for value
+    #
+    # @example
+    #   condition = Selector::Function.new -> v { v[/foo/] }
+    #   condition[:foo] # => true
+    #   condition[:bar] # => false
+    #
+    # @param (see Selector::Condition#[])
+    #
+    # @return (see Selector::Condition#[])
+    #
+    def [](value)
+      attribute.call(value) ? true : false
+    end
+
+  end # class Function
+
+end # module Selector

data/lib/selector/not.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Selector
+
+  # The inversion of another condition
+  #
+  class Not < Condition
+
+    # @private
+    def self.new(source)
+      return NOTHING  if source.equal? ANYTHING
+      return ANYTHING if source.equal? NOTHING
+      super
+    end
+
+    # Checks if the value doesn't satisfy inverted condition
+    #
+    # @example
+    #   condition = Selector.new(only: [:foo])
+    #   inversion[:foo] # => true
+    #   inversion[:bar] # => false
+    #
+    #   inversion = Not.new(condition)
+    #   inversion[:foo] # => false
+    #   inversion[:bar] # => true
+    #
+    # @param (see Selector::Condition#[])
+    #
+    # @return (see Selector::Condition#[])
+    #
+    def [](value)
+      !attribute[value]
+    end
+
+    # Returns the inverted condition (avoids double negation)
+    #
+    # @example
+    #   condition = Selector.new(only: [:foo])
+    #   inversion = Not.new(condition)
+    #   !inversion == condition # => true
+    #
+    # @return (see Selector::Condition#!)
+    #
+    def !
+      attribute
+    end
+
+  end # class Not
+
+end # module Selector

data/lib/selector/nothing.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Selector
+
+  # The condition that accepts any value
+  #
+  # @example (see #[])
+  #
+  class Nothing < Condition
+
+    include Singleton
+
+    # @!method [](value)
+    # Returns false
+    #
+    # @example
+    #   condition = Selector::Nothing.instance # singleton
+    #   condition[:foo] # => false
+    #
+    # @param (see Selector::Condition#[])
+    #
+    # @return [false]
+    #
+    def [](_value)
+      false
+    end
+
+  end # class Nothing
+
+end # module Selector

data/lib/selector/or.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Selector
+
+  # The composition of several conditions. Requires any of them to be satisfied
+  #
+  # @example (see #[])
+  #
+  class Or < Condition
+
+    # @private
+    def self.new(*attributes)
+      attrs = attributes.uniq - [NOTHING]
+
+      return NOTHING     if attrs.empty?
+      return attrs.first if attrs.count.equal?(1)
+      return ANYTHING    if attrs.include? ANYTHING
+      return ANYTHING    if (attrs & attrs.map(&:!)).any?
+
+      super(*attrs)
+    end
+
+    # Checks if value satisfies any of composed conditions
+    #
+    #   @example
+    #     left  = Selector.new only: /foo/
+    #     right = Selector.new only: /bar/
+    #     composition = Selector::Or.new(left, right)
+    #
+    #     composition[:foo] # => true
+    #     composition[:bar] # => true
+    #     composition[:baz] # => false
+    #
+    # @param (see Selector::Composition#[])
+    #
+    # @return (see Selector::Composition#[])
+    #
+    def [](value)
+      attributes.detect { |part| part[value] } ? true : false
+    end
+
+    # Adds the other condition to the composition (avoids nesting)
+    #
+    # @param (see Selector::Composition#|)
+    #
+    # @return (see Selector::Composition#|)
+    #
+    def |(other)
+      Or.new(*attributes, other)
+    end
+
+  end # class Or
+
+end # module Selector

data/lib/selector/regexp.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Selector
+
+  # The condition checks if a value matches the regexp
+  #
+  # @example (see #[])
+  #
+  class Regexp < Condition
+
+    # Initializes the condition with the regexp
+    #
+    # @param [::Regexp] regexp
+    #
+    def initialize(_)
+      super
+    end
+
+    # Checks if the stringified value matches the regexp
+    #
+    # @example
+    #   condition = Selector::Regexp.new /1/
+    #   condition[11] # => true
+    #   condition[22] # => false
+    #
+    # @param (see Selector::Condition#[])
+    #
+    # @return (see Selector::Condition#[])
+    #
+    def [](value)
+      value.to_s[attribute] ? true : false
+    end
+
+    # Creates an OR composition
+    #
+    # If other value is a regexp, then creates modified regexp to avoid nesting
+    #
+    # @param (see Selector::Composition#|)
+    #
+    # @return (see Selector::Composition#|)
+    #
+    def |(other)
+      return super unless other.instance_of? Regexp
+      Regexp.new(/(#{attribute})|(#{other.attribute})/)
+    end
+
+  end # class Regexp < Condition
+
+end # module Selector

data/lib/selector/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module Selector
+
+  # The semantic version of the gem.
+  # @see http://semver.org/ Semantic versioning 2.0
+  VERSION = "0.0.1".freeze
+
+end # module Selector

data/selector.gemspec

@@ -0,0 +1,25 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "selector/version"
+
+Gem::Specification.new do |gem|
+
+  gem.name        = "selector"
+  gem.version     = Selector::VERSION.dup
+  gem.author      = "Andrew Kozin"
+  gem.email       = "andrew.kozin@gmail.com"
+  gem.homepage    = "https://github.com/nepalez/selector"
+  gem.summary     = "Composable multi-type conditions."
+  gem.license     = "MIT"
+
+  gem.files            = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.test_files       = Dir["spec/**/*.rb"]
+  gem.extra_rdoc_files = Dir["README.md", "LICENSE"]
+  gem.require_paths    = ["lib"]
+
+  gem.required_ruby_version = "~> 1.9.3"
+
+  gem.add_runtime_dependency "ice_nine", "~> 0.11"
+
+  gem.add_development_dependency "hexx-rspec", "~> 0.5"
+
+end # Gem::Specification

data/spec/integration/blacklist_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+describe "Blacklist" do
+
+  it "works with array" do
+    selector = Selector.new except: [:foo, :qux]
+
+    expect(selector[:foo]).to eql(false)
+    expect(selector[:bar]).to eql(true)
+  end
+
+  it "works with regexp" do
+    selector = Selector.new except: /foo/
+
+    expect(selector[:foobar]).to eql(false)
+    expect(selector[:bar]).to eql(true)
+  end
+
+  it "works with range" do
+    selector = Selector.new except: 1..3
+
+    expect(selector[2.4]).to eql(false)
+    expect(selector[0]).to eql(true)
+  end
+
+  it "works with proc" do
+    selector = Selector.new except: -> value { value.is_a? Hash }
+
+    expect(selector[foo: :FOO]).to eql(false)
+    expect(selector[:foo]).to eql(true)
+  end
+
+end # describe Whitelist

data/spec/integration/composition_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+describe "Composition" do
+
+  it "& works" do
+    blacklist = Selector.new except: /bar/
+    whitelist = Selector.new only: /foo/
+    selector = whitelist & blacklist
+
+    expect(selector[:foobaz]).to eql(true)
+    expect(selector[:foobar]).to eql(false)
+  end
+
+  it "- works" do
+    whitelist = Selector.new only: /foo/
+    blacklist = Selector.new except: /bar/
+    selector = whitelist - blacklist
+
+    expect(selector[:foobar]).to eql(true)
+    expect(selector[:bar]).to eql(false)
+    expect(selector[:foo]).to eql(false)
+  end
+
+  it "| works" do
+    whitelist = Selector.new only: 4..8
+    blacklist = Selector.new except: 1..5
+    selector = whitelist | blacklist
+
+    expect(selector[0.5]).to eql(true)
+    expect(selector[5.5]).to eql(true)
+    expect(selector[2.5]).to eql(false)
+  end
+
+end # describe Composition

data/spec/integration/negation_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+describe "Negation" do
+
+  it "works" do
+    blacklist = Selector.new except: /bar/
+    selector = !blacklist
+
+    expect(selector[:foo]).to eql(false)
+    expect(selector[:bar]).to eql(true)
+  end
+
+end # describe Negation

data/spec/integration/whitelist_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+describe "Whitelist" do
+
+  it "works with array" do
+    selector = Selector.new only: [:foo, :qux]
+
+    expect(selector[:foo]).to eql(true)
+    expect(selector[:bar]).to eql(false)
+  end
+
+  it "works with regexp" do
+    selector = Selector.new only: /foo/
+
+    expect(selector[:foobar]).to eql(true)
+    expect(selector[:bar]).to eql(false)
+  end
+
+  it "works with range" do
+    selector = Selector.new only: 1..3
+
+    expect(selector[2.4]).to eql(true)
+    expect(selector[0]).to eql(false)
+  end
+
+  it "works with proc" do
+    selector = Selector.new only: -> value { value.is_a? Hash }
+
+    expect(selector[foo: :FOO]).to eql(true)
+    expect(selector[:foo]).to eql(false)
+  end
+
+end # describe Whitelist

data/spec/shared/generator.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+# Generates the condition object with regexp
+def generate(regexp)
+  klass = Class.new(Selector::Condition)
+  klass.send(:define_method, :[]) { |value| nil ^ value[regexp] }
+  klass.new
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+begin
+  require "hexx-suit"
+  Hexx::Suit.load_metrics_for(self)
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.load_metrics_for(self)
+end
+
+# Loads the code under test
+require "selector"

data/spec/unit/selector/and_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require "shared/generator"
+
+module Selector
+
+  describe Selector::And 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 ANYTHING when possible" do
+        subject = described_class.new ANYTHING
+        expect(subject).to eql ANYTHING
+      end
+
+      it "returns NOTHING if exists" do
+        subject = described_class.new foo, bar, NOTHING
+        expect(subject).to eql NOTHING
+      end
+
+      it "returns NOTHING when possible" do
+        subject = described_class.new foo, !foo
+        expect(subject).to eql NOTHING
+      end
+
+      it "returns the only attribute" do
+        subject = described_class.new foo, ANYTHING
+        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 ANYTHING" do
+        subject = described_class.new foo, bar, ANYTHING
+        expect(subject.attributes).to eql [foo, bar]
+      end
+
+    end # describe .new
+
+    describe "#[]" do
+
+      subject { composition[value] }
+
+      context "when all conditions are satisfied" do
+
+        let(:value) { "foobar" }
+        it { is_expected.to eql(true) }
+
+      end # context
+
+      context "when any condition isn't satisfied" do
+
+        let(:value) { "foo" }
+        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 #&
+
+    describe "#-" do
+
+      subject { composition - baz }
+
+      it { is_expected.to be_kind_of(described_class) }
+
+      it "updates conditions (avoids nesting)" do
+        expect(subject.attributes).to contain_exactly(foo, bar, !baz)
+      end
+
+    end # describe #-
+
+  end # describe Selector::And
+
+end # module Selector