query_string_search 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b484ab328b2b5e889f3c0760ef857b3eccdddd8
-  data.tar.gz: d0071f6f1ca439042d640ce53271beda186375e2
+  metadata.gz: d98152d90936269401df2e71217c03c41c5f249a
+  data.tar.gz: b9d1b39ecfb46a0fbc15816e849575c30970e571
 SHA512:
-  metadata.gz: 44babe5feac2376030fe68edaa8a740c7f684959de01142558faa0d108ae86fc29ceeec5fd4a37896f38a19f6c95783c9da365afdea532632ab3e0ed110282f7
-  data.tar.gz: bc97993d98ba3a8fd352729a2bbbb3a329ee1d28d957c926e210f311fd42670526b538834a423092bdac947b519d0d3e4c99849cf47886b30722b908025d1bb5
+  metadata.gz: 731af57376be5e8859edc378c5d2c3b6c41196ae88c4bda918ca0f973713fb5bfcc1a6f3d0844977deca202b278c74219341a48545bce9fc08250e9195e29bbf
+  data.tar.gz: 4c1a8a92387aeb3390f4a46a0b40746b2dcc031b9586bbe0138dbce930e6360cb62d906f17b013006549580216bdf05e7d38b1f8267f0c37cd7d79c10ad48134

data/.travis.yml

@@ -6,4 +6,4 @@ rvm:
 addons:
   code_climate:
     repo_token:
-      secure: XnZ8VLwsAVr3lrJ3gInolfi1dALfyu0XF74t7VExawsSGuDJzFnx4lwqw139uQHqEUNOl/lj+SHMjgEIxtoM6LjX/JBiCQLTMyKKz5EMwUvFULz4vWaGy2mgyA48WDXZL/s1k0GW7/Q8wxpdQ7uU2izx2RaJ+PLmcYUNQhNBbMI=
+      secure: xcf282dQMF1ZUZ9V9a/oY6zVo+nacSJqsxWJ7W8bOA4ii+Xq44EKLp1x88XSnWsD+yD3bdw4mHtPoQDCa+ouJLul5p35TwVZWGVxNdnWUdr3CjCS8lw4DYyR8BUHtH10JvvQN3AZpQ5IeHFqAujVMumfAPRkeuOLMs8iyfezrpI=

data/README.md

@@ -34,6 +34,32 @@ Returns every movie with a year of 1994
 
 Returns all movies with a year of 1994 or 1995
 
+### Return all data with values greater than or less than an attribute
+
+`movies?q=star_rating>1`
+Returns all movies with a star rating greater than one
+
+`movies?q=star_rating<3`
+Returns all movies with a star rating less than three
+
+`movies?q=star_rating>=2`
+Returns all movies with a star rating greater than or equal to 2
+
+`movies?q=star_rating<=4`
+Returns all movies with a star rating less than or equal to 4
+
+### Search an attribute that returns a collection
+
+If your `movie` has a `home_formats` method that retuns an array like `["DVD", "BD"]` you can filter that too.
+
+`movies?q=home_formats=DVD`
+Returns all movies whose `home_formats` includes "DVD"
+
+or
+
+`movies?q=home_formats=BD|DVD`
+Returns all movies whose `home_formats` includes "DVD" or "BD"
+
 ### Combining Searches
 
 Search criteria can be separated with commas

data/lib/query_string_search.rb

@@ -4,7 +4,8 @@ module QueryStringSearch
   end
 
   class Search
-    attr_accessor :data_source, :query_string
+    attr_accessor :data_source
+    attr_reader :query_string
 
     def initialize(data_source, query_string)
       self.data_source = data_source
@@ -21,6 +22,10 @@ module QueryStringSearch
 
     private
 
+    def query_string=(x)
+      @query_string = x ? CGI.unescape(x) : nil
+    end
+
     def filter_by_param(data, param)
       data.select { |c| param.match?(c) }
     end

data/lib/query_string_search/abstract_comparison.rb

@@ -0,0 +1,38 @@
+require "delegate"
+
+module QueryStringSearch
+  module Comparator
+    class AbstractComparison
+      attr_accessor :other, :subject, :operator
+
+      def self.comparisons
+        descendants.push(self)
+      end
+
+      def self.descendants
+        ObjectSpace.each_object(Class).select { |klass| klass < AbstractComparison }
+      end
+
+      def self.all_reserved_operators
+        descendants.each_with_object([]) { |d, ret| ret << d.reserved_operators }.flatten
+      end
+
+      def self.reserved_operators
+        []
+      end
+
+      def normalize(unnormalized)
+        Array(unnormalized).map(&:to_s).map(&:upcase)
+      end
+
+      def compare
+        false
+      end
+
+      def self.build_me?(_)
+        true
+      end
+    end
+  end
+end
+Dir.glob(File.join(File.dirname(__FILE__), "comparisons", "*.rb")) { |file| require file }

data/lib/query_string_search/abstract_matcher.rb

@@ -1,6 +1,7 @@
 module QueryStringSearch
   class AbstractMatcher
-    attr_accessor :attribute, :value
+    attr_accessor :attribute, :desired_value
+    attr_reader :operator
 
     def self.matchers
       descendants.push(self)
@@ -14,11 +15,6 @@ module QueryStringSearch
       descendants.each_with_object([]) { |d, ret| ret << d.reserved_words }.flatten
     end
 
-    def initialize(attribute = nil, value = nil)
-      self.attribute = attribute
-      self.value = value
-    end
-
     def match?(_)
       false
     end
@@ -27,10 +23,18 @@ module QueryStringSearch
       []
     end
 
-    def self.build_me?(_, _)
+    def self.build_me?(_)
       true
     end
 
+    def operator=(x)
+      @operator = x.to_s.to_sym
+    end
+
+    def comparison
+      @comparison ||= QueryStringSearch::Comparator::ComparisonFactory.build(self)
+    end
+
     private
 
     def match_with_contingency
@@ -38,6 +42,10 @@ module QueryStringSearch
     rescue
       false
     end
+
+    def actual_value(actual)
+      actual.public_send(attribute)
+    end
   end
 end
 Dir.glob(File.join(File.dirname(__FILE__), "matchers", "*.rb")) { |file| require file }

data/lib/query_string_search/comparison_factory.rb

@@ -0,0 +1,16 @@
+module QueryStringSearch
+  module Comparator
+    class ComparisonFactory
+      def self.build(matcher, available_comparisons = AbstractComparison.comparisons)
+        comparison_to_build = available_comparisons.detect { |c| c.build_me?(matcher) }
+
+        if comparison_to_build
+          comparison = comparison_to_build.new
+          comparison.subject = matcher.desired_value
+          comparison.operator = matcher.operator
+          comparison
+        end
+      end
+    end
+  end
+end

data/lib/query_string_search/comparisons/inequality.rb

@@ -0,0 +1,21 @@
+module QueryStringSearch
+  module Comparator
+    class Inequality < AbstractComparison
+      def compare(other)
+        normalize(other).public_send(operator, normalize(subject))
+      end
+
+      def normalize(unnormalized)
+        unnormalized.to_i
+      end
+
+      def self.reserved_operators
+        [:<, :>, :<=, :>=]
+      end
+
+      def self.build_me?(matcher)
+        reserved_operators.include?(matcher.operator)
+      end
+    end
+  end
+end

data/lib/query_string_search/comparisons/set.rb

@@ -0,0 +1,13 @@
+module QueryStringSearch
+  module Comparator
+    class Set < AbstractComparison
+      def compare(other)
+        (normalize(subject) & normalize(other)).any?
+      end
+
+      def self.build_me?(matcher)
+        all_reserved_operators.none? { |o| o == matcher.operator }
+      end
+    end
+  end
+end

data/lib/query_string_search/matcher_factory.rb

@@ -1,10 +1,14 @@
 module QueryStringSearch
   class MatcherFactory
-    def self.build(query_option, build_options)
-      constructor = build_options.detect { |m| m.build_me?(query_option.search_type, query_option.search_param) }
+    def self.build(search_option, build_options)
+      matcher_to_build = build_options.detect { |m| m.build_me?(search_option) }
 
-      if constructor
-        constructor.new(query_option.search_type, query_option.search_param)
+      if matcher_to_build
+        matcher               = matcher_to_build.new
+        matcher.attribute     = search_option.attribute
+        matcher.desired_value = search_option.desired_value
+        matcher.operator      = search_option.operator
+        matcher
       end
     end
   end

data/lib/query_string_search/matchers/match_all.rb

@@ -3,7 +3,7 @@ class MatchAll < QueryStringSearch::AbstractMatcher
     true
   end
 
-  def self.build_me?(search_type, search_param)
-    search_type.nil? && search_param.nil?
+  def self.build_me?(search_option)
+    search_option.attribute.nil? && search_option.desired_value.nil?
   end
 end

data/lib/query_string_search/matchers/match_attribute.rb

@@ -1,6 +1,6 @@
 class MatchAttribute < QueryStringSearch::AbstractMatcher
-  def match?(target)
-    match_with_contingency { target.public_send(attribute) }
+  def match?(data)
+    match_with_contingency { actual_value(data) }
   end
 
   def self.reserved_words
@@ -10,7 +10,7 @@ class MatchAttribute < QueryStringSearch::AbstractMatcher
     ]
   end
 
-  def self.build_me?(_, search_param)
-    reserved_words.any? { |r| r.match(search_param) }
+  def self.build_me?(search_option)
+    reserved_words.any? { |r| r.match(search_option.desired_value) }
   end
 end

data/lib/query_string_search/matchers/match_attribute_value.rb

@@ -1,13 +1,13 @@
 class MatchAttributeValue < QueryStringSearch::AbstractMatcher
-  def match?(target)
+  def match?(data)
     match_with_contingency do
-      target.public_send(attribute).to_s.upcase == value.to_s.upcase
+      comparison.compare(actual_value(data))
     end
   end
 
-  def self.build_me?(search_type, search_param)
-    search_param &&
-      search_type &&
-      all_reserved_words.none? { |r| r.match(search_param) }
+  def self.build_me?(search_option)
+    search_option.desired_value &&
+      search_option.attribute &&
+      all_reserved_words.none? { |r| r.match(search_option.desired_value) }
   end
 end

data/lib/query_string_search/matchers/match_multiple_attribute_values.rb

@@ -1,21 +1,25 @@
 class MatchMultipleAttributeValues < QueryStringSearch::AbstractMatcher
-  def match?(target)
+  def match?(data)
     match_with_contingency do
-      value.include?(target.public_send(attribute).to_s.upcase)
+      comparison.compare(actual_value(data))
     end
   end
 
+  def operator
+    :&
+  end
+
   def self.reserved_words
     [
       /^\w+\|\w+/
     ]
   end
 
-  def value=(x)
-    super(x.split("|").map(&:upcase))
+  def desired_value=(x)
+    super(x.split("|"))
   end
 
-  def self.build_me?(_, search_param)
-    reserved_words.any? { |r| r.match(search_param) }
+  def self.build_me?(search_option)
+    reserved_words.any? { |r| r.match(search_option.desired_value) }
   end
 end

data/lib/query_string_search/matchers/match_no_attribute.rb

@@ -1,6 +1,6 @@
 class MatchNoAttribute < QueryStringSearch::AbstractMatcher
-  def match?(target)
-    match_with_contingency { !target.public_send(attribute) }
+  def match?(data)
+    match_with_contingency { !actual_value(data) }
   end
 
   def self.reserved_words
@@ -10,7 +10,7 @@ class MatchNoAttribute < QueryStringSearch::AbstractMatcher
     ]
   end
 
-  def self.build_me?(_, search_param)
-    reserved_words.any? { |r| r.match(search_param) }
+  def self.build_me?(search_option)
+    reserved_words.any? { |r| r.match(search_option.desired_value) }
   end
 end

data/lib/query_string_search/search_option.rb

@@ -0,0 +1,35 @@
+module QueryStringSearch
+  class SearchOption
+    attr_reader :attribute, :desired_value, :operator
+
+    def initialize(raw_query)
+      parsed_query       = KeyValue.parse(raw_query)
+      self.attribute     = parsed_query.attribute
+      self.desired_value = parsed_query.desired_value
+      self.operator      = parsed_query.operator
+    end
+
+    def attribute
+      @attribute ? @attribute.to_sym : nil
+    end
+
+    private
+
+    attr_writer :attribute, :desired_value, :operator
+  end
+
+  class KeyValue
+    attr_accessor :attribute, :desired_value, :operator
+
+    def self.parse(raw_query)
+      new(/(?<attribute>\w+)(?<operator>\W+)(?<desired_value>.+)/.match(raw_query))
+    end
+
+    def initialize(match_data)
+      match_data         = match_data ? match_data : {}
+      self.attribute     = match_data[:attribute]
+      self.desired_value = match_data[:desired_value]
+      self.operator      = match_data[:operator]
+    end
+  end
+end

data/lib/query_string_search/search_options.rb

@@ -1,32 +1,13 @@
 module QueryStringSearch
-  class SearchOptions
-    attr_reader :search_type, :search_param
-
+  module SearchOptions
     def self.parse(query_string)
       if query_string
-        search_params = query_string.split(",")
-        search_params.each_with_object([]) do |p, ret|
-          ret << new(p)
+        query_string.split(",").each_with_object([]) do |p, ret|
+          ret << QueryStringSearch::SearchOption.new(p)
         end
       else
-        [new(nil)]
+        [QueryStringSearch::SearchOption.new(nil)]
       end
     end
-
-    def initialize(raw_query)
-      self.search_type, self.search_param = raw_query.to_s.split("=")
-    end
-
-    def search_type
-      @search_type ? @search_type.to_sym : nil
-    end
-
-    def search_param
-      @search_param ? CGI.unescape(@search_param) : @search_param
-    end
-
-    private
-
-    attr_writer :search_type, :search_param
   end
 end

data/lib/query_string_search/search_parameters.rb

@@ -5,13 +5,13 @@ module QueryStringSearch
     def_delegators :@collection, :each
 
     def self.build_from_querystring(query_string, factory = QueryStringSearch::MatcherFactory, matchers = QueryStringSearch::AbstractMatcher.matchers)
-      parameters = QueryStringSearch::SearchOptions.parse(query_string)
-      new(parameters, factory, matchers)
+      search_options = QueryStringSearch::SearchOptions.parse(query_string)
+      new(search_options, factory, matchers)
     end
 
-    def initialize(parameters, factory, matchers)
-      parameters.each do |param|
-        collection << factory.build(param, matchers)
+    def initialize(search_options, factory, matchers)
+      search_options.each do |search_option|
+        collection << factory.build(search_option, matchers)
       end
     end
 

data/lib/query_string_search/version.rb

@@ -1,3 +1,3 @@
 module QueryStringSearch
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/features/find_records_by_searching_a_attribute_that_returns_a_collection_spec.rb

@@ -0,0 +1,23 @@
+require_relative "../../lib/query_string_search"
+require_relative "../fixtures/movie"
+
+RSpec.describe "Finding data based on an attribute that returns a collection" do
+  let(:data_set) { Movie.random_collection }
+
+  let(:movies_on_dvd) { data_set.select { |d| d.home_formats.include?("DVD") } }
+  let(:movies_on_dvd_or_bd) { data_set.select { |d| d.home_formats.include?("DVD") || d.home_formats.include?("BD") } }
+
+  it "Returns the correct records when searching for one value" do
+    query_string = "home_formats=DVD"
+    results = QueryStringSearch.new(data_set, query_string).results
+
+    expect(results).to eq(movies_on_dvd)
+  end
+
+  it "Returns the correct records when searching for two values" do
+    query_string = "home_formats=DVD|BD"
+    results = QueryStringSearch.new(data_set, query_string).results
+
+    expect(results).to eq(movies_on_dvd_or_bd)
+  end
+end

data/spec/features/find_records_with_inequality_matchers_spec.rb

@@ -0,0 +1,48 @@
+require_relative "../../lib/query_string_search"
+require_relative "../fixtures/movie"
+
+RSpec.describe "Finding data with inequality matchers" do
+  describe "Allows searching for values greater than a number" do
+    let(:data_set) { Movie.random_collection }
+    let(:movies_with_more_than_one_star) { data_set.select { |d| d.star_rating > 1 } }
+
+    it "Returns records that match the requested value" do
+      results = QueryStringSearch.new(data_set, "star_rating>1").results
+
+      expect(results).to eq(movies_with_more_than_one_star)
+    end
+  end
+
+  describe "Allows searching for values less than a number" do
+    let(:data_set) { Movie.random_collection }
+    let(:movies_with_fewer_than_three_stars) { data_set.select { |d| d.star_rating < 3 } }
+
+    it "Returns records that match the requested value" do
+      results = QueryStringSearch.new(data_set, "star_rating<3").results
+
+      expect(results).to eq(movies_with_fewer_than_three_stars)
+    end
+  end
+
+  describe "Allows searching for values greater than or equal to a number" do
+    let(:data_set) { Movie.random_collection }
+    let(:movies_with_two_or_more_stars) { data_set.select { |d| d.star_rating >= 2 } }
+
+    it "Returns records that match the requested value" do
+      results = QueryStringSearch.new(data_set, "star_rating>=2").results
+
+      expect(results).to eq(movies_with_two_or_more_stars)
+    end
+  end
+
+  describe "Allows searching for values less than or equal to a number" do
+    let(:data_set) { Movie.random_collection }
+    let(:movies_with_four_or_fewer_stars) { data_set.select { |d| d.star_rating <= 4 } }
+
+    it "Returns records that match the requested value" do
+      results = QueryStringSearch.new(data_set, "star_rating<=4").results
+
+      expect(results).to eq(movies_with_four_or_fewer_stars)
+    end
+  end
+end

data/spec/fixtures/movie.rb

@@ -1,37 +1,41 @@
 class Movie
-  attr_accessor :title, :rating, :year, :country, :seen
+  attr_accessor :title, :rating, :year, :country, :seen, :star_rating, :home_formats
 
-  def self.random_collection(count = 1_000)
-    (1...count).inject([]) do |collection, _|
-      collection << Movie.new(random_title, random_rating, random_year, random_country)
-    end
+  def self.random_collection(count = 100)
+    (1...count).map { |_| Movie.random }
   end
 
-  def initialize(title, rating, year, country)
-    self.title   = title
-    self.rating  = rating
-    self.year    = year
-    self.country = country
-    self.seen    = [true, false].sample
+  def self.random
+    Movie.new
+  end
+
+  def initialize
+    self.title       = random_title
+    self.rating      = random_rating
+    self.year        = random_year
+    self.country     = random_country
+    self.seen        = [true, false].sample
+    self.star_rating = [1, 2, 3, 4, 5].sample
+    self.home_formats = %w(BD DVD Hulu Amazon Netflix).sample(2)
   end
 
   def seen?
     seen
   end
 
-  def self.random_title
+  def random_title
     "Random Movie #{rand(10_000)}"
   end
 
-  def self.random_rating
+  def random_rating
     ["X", "NC-17", "R", "PG-13", "PG", "G", nil].sample
   end
 
-  def self.random_year
+  def random_year
     (1990..2014).to_a.sample.to_s
   end
 
-  def self.random_country
+  def random_country
     %w(
       US CAN UK HK BR RUS FR IN
     ).sample

data/spec/lib/query_string_search/abstract_matcher_spec.rb

@@ -6,14 +6,17 @@ RSpec.describe QueryStringSearch::AbstractMatcher do
     it "is false" do
       value = rand
       target = OpenStruct.new(other: value)
-      it = QueryStringSearch::AbstractMatcher.new(:other, value)
+      it = QueryStringSearch::AbstractMatcher.new
+      it.attribute = :other
+      it.desired_value = value
+      it.operator = "="
       expect(it.match?(target)).to be_falsey
     end
   end
 
   describe "build_me?" do
     it "is true" do
-      it = QueryStringSearch::AbstractMatcher.build_me?(rand, rand)
+      it = QueryStringSearch::AbstractMatcher.build_me?(Object.new)
       expect(it).to be_truthy
     end
   end

data/spec/lib/query_string_search/matcher_factory_spec.rb

@@ -7,16 +7,21 @@ RSpec.describe QueryStringSearch::MatcherFactory do
   let(:build_candidates) { [matcher_double] }
 
   before do
-    allow(param_double).to receive(:search_param).and_return("test_search_param")
-    allow(param_double).to receive(:search_type).and_return("test_search_type")
+    allow(param_double).to receive(:desired_value).and_return("test_search_value")
+    allow(param_double).to receive(:attribute).and_return("test_search_attribute")
+    allow(param_double).to receive(:operator).and_return("test_operator")
   end
 
   describe "build" do
     describe "finds a matcher to build" do
-      it "builds that matcher and returns it" do
-        test_return = Object.new
-        expect(matcher_double).to receive(:build_me?).with(param_double.search_type, param_double.search_param).and_return(true)
-        expect(matcher_double).to receive(:new).with(param_double.search_type, param_double.search_param).and_return(test_return)
+      it "builds that matcher, configures and returns it" do
+        test_return = instance_double(QueryStringSearch::AbstractMatcher.matchers.sample)
+        expect(test_return).to receive(:attribute=).with("test_search_attribute")
+        expect(test_return).to receive(:desired_value=).with("test_search_value")
+        expect(test_return).to receive(:operator=).with("test_operator")
+
+        expect(matcher_double).to receive(:build_me?).with(param_double).and_return(true)
+        expect(matcher_double).to receive(:new).and_return(test_return)
         expect(QueryStringSearch::MatcherFactory.build(param_double, build_candidates)).to eq(test_return)
       end
     end

data/spec/lib/query_string_search/matchers/match_all_spec.rb

@@ -3,23 +3,38 @@ require_relative "../../../../lib/query_string_search/abstract_matcher"
 RSpec.describe MatchAll do
   describe "match?" do
     it "is true" do
-      it = MatchAll.new(:other, rand)
+      it = MatchAll.new
+      it.attribute = :other
+      it.desired_value = rand
       expect(it.match?(rand)).to be_truthy
     end
   end
 
   describe "build_me?" do
-    describe "given a nil search_type and search_param" do
+    let(:search_option) { instance_double(QueryStringSearch::SearchOption) }
+
+    describe "given a nil attribute and desired_value" do
       it "is true" do
-        expect(MatchAll.build_me?(nil, nil)).to be_truthy
+        allow(search_option).to receive(:attribute).and_return(nil)
+        allow(search_option).to receive(:desired_value).and_return(nil)
+
+        expect(MatchAll.build_me?(search_option)).to be_truthy
       end
     end
 
-    describe "given a non-nil search_type or search_param" do
+    describe "given a non-nil attribute or desired_value" do
       it "is false" do
-        expect(MatchAll.build_me?(rand, nil)).to be_falsey
-        expect(MatchAll.build_me?(nil, rand)).to be_falsey
-        expect(MatchAll.build_me?(rand, rand)).to be_falsey
+        allow(search_option).to receive(:attribute).and_return(rand)
+        allow(search_option).to receive(:desired_value).and_return(nil)
+        expect(MatchAll.build_me?(search_option)).to be_falsey
+
+        allow(search_option).to receive(:attribute).and_return(nil)
+        allow(search_option).to receive(:desired_value).and_return(rand)
+        expect(MatchAll.build_me?(search_option)).to be_falsey
+
+        allow(search_option).to receive(:attribute).and_return(rand)
+        allow(search_option).to receive(:desired_value).and_return(rand)
+        expect(MatchAll.build_me?(search_option)).to be_falsey
       end
     end
   end

data/spec/lib/query_string_search/matchers/match_attribute_spec.rb

@@ -5,63 +5,72 @@ RSpec.describe MatchAttribute do
   describe "match?" do
     describe "if the target's attribute is not nil" do
       let(:target) { SearchTarget.new(property: "search_value") }
-      let(:subject) { MatchAttribute.new(:property) }
 
       it "is true" do
-        expect(subject.match?(target)).to be_truthy
+        matcher = MatchAttribute.new
+        matcher.attribute = :property
+        expect(matcher.match?(target)).to be_truthy
       end
     end
 
     describe "if the target's attribute is true" do
       let(:target) { SearchTarget.new(property: true) }
-      let(:subject) { MatchAttribute.new(:property) }
 
       it "is true" do
-        expect(subject.match?(target)).to be_truthy
+        matcher = MatchAttribute.new
+        matcher.attribute = :property
+        expect(matcher.match?(target)).to be_truthy
       end
     end
 
     describe "if the target's attribute is nil" do
       let(:target) { SearchTarget.new(property: nil) }
-      let(:subject) { MatchAttribute.new(:property) }
 
       it "is false" do
-        expect(subject.match?(target)).to be_falsey
+        matcher = MatchAttribute.new
+        matcher.attribute = :property
+        expect(matcher.match?(target)).to be_falsey
       end
     end
 
     describe "if the target's attribute is false" do
       let(:target) { SearchTarget.new(property: false) }
-      let(:subject) { MatchAttribute.new(:property) }
 
       it "is true" do
-        expect(subject.match?(target)).to be_falsey
+        matcher = MatchAttribute.new
+        matcher.attribute = :property
+        expect(matcher.match?(target)).to be_falsey
       end
     end
 
     describe "if the target doesn't have the attribute" do
       let(:target) { SearchTarget.new(property: rand) }
-      let(:subject) { MatchAttribute.new(:bad_attr) }
 
       it "is false" do
-        expect(subject.match?(target)).to be_falsey
+        matcher = MatchAttribute.new
+        matcher.attribute = :bat_attr
+        expect(matcher.match?(target)).to be_falsey
       end
     end
   end
 
   describe "build_me?" do
-    describe "given a search param of 'all' or 'true'" do
+    let(:search_option) { instance_double(QueryStringSearch::SearchOption) }
+
+    describe "given a value of 'all' or 'true'" do
       it "is true" do
-        %w(all true).each do |search_param|
-          expect(MatchAttribute.build_me?(rand, search_param)).to be_truthy
+        %w(all true).each do |desired_value|
+          allow(search_option).to receive(:desired_value).and_return(desired_value)
+          expect(MatchAttribute.build_me?(search_option)).to be_truthy
         end
       end
     end
 
-    describe "given a search param that is not 'all' or 'true'" do
+    describe "given a value that is not 'all' or 'true'" do
       it "is false" do
-        %w(1all rue).each do |search_param|
-          expect(MatchAttribute.build_me?(rand, search_param)).to be_falsey
+        %w(1all rue).each do |desired_value|
+          allow(search_option).to receive(:desired_value).and_return(desired_value)
+          expect(MatchAttribute.build_me?(search_option)).to be_falsey
         end
       end
     end

data/spec/lib/query_string_search/matchers/match_attribute_value_spec.rb

@@ -5,53 +5,77 @@ RSpec.describe MatchAttributeValue do
   describe "match?" do
     describe "given a target with an attribute that matches the Parameter's attribute" do
       let(:target) { SearchTarget.new(property: "search_value") }
-      let(:subject) { MatchAttributeValue.new(:property, "search_value") }
 
       it "returns true" do
-        expect(subject.match?(target)).to be_truthy
+        matcher = MatchAttributeValue.new
+        matcher.attribute = :property
+        matcher.desired_value = "search_value"
+        matcher.operator = "="
+        expect(matcher.match?(target)).to be_truthy
       end
     end
 
     describe "given a value with spaces" do
       let(:target) { SearchTarget.new(property: "search value") }
-      let(:subject) { MatchAttributeValue.new(:property, "search value") }
 
       it "returns true" do
-        expect(subject.match?(target)).to be_truthy
+        matcher = MatchAttributeValue.new
+        matcher.attribute = :property
+        matcher.desired_value = "search value"
+        matcher.operator = "="
+        expect(matcher.match?(target)).to be_truthy
       end
     end
 
     describe "given a target with an attribute that does not match the Parameter's attribute" do
       let(:target) { SearchTarget.new(property: "other_value") }
-      let(:subject) { MatchAttributeValue.new(:property, "search_value") }
 
       it "returns false" do
-        expect(subject.match?(target)).to be_falsey
+        matcher = MatchAttributeValue.new
+        matcher.attribute = :property
+        matcher.desired_value = "search_value"
+        matcher.operator = "="
+        expect(matcher.match?(target)).to be_falsey
       end
     end
 
     describe "if the target doesn't have the attribute" do
       let(:target) { SearchTarget.new(property: "search_value") }
-      let(:subject) { MatchAttribute.new(:bad_attr, "search_value") }
 
       it "is false" do
-        expect(subject.match?(target)).to be_falsey
+        matcher = MatchAttributeValue.new
+        matcher.attribute = :bat_attr
+        matcher.desired_value = "search_value"
+        matcher.operator = "="
+        expect(matcher.match?(target)).to be_falsey
       end
     end
   end
 
   describe "build_me?" do
-    describe "given a non-nil search_type and search_param" do
+    let(:search_option) { instance_double(QueryStringSearch::SearchOption) }
+
+    describe "given a non-nil attribute and desired_value" do
       it "is true" do
-        expect(MatchAttributeValue.build_me?(rand.to_s, rand.to_s)).to be_truthy
+        allow(search_option).to receive(:attribute).and_return(rand.to_s)
+        allow(search_option).to receive(:desired_value).and_return(rand.to_s)
+        expect(MatchAttributeValue.build_me?(search_option)).to be_truthy
       end
     end
 
-    describe "given a nil search_type or search_param" do
+    describe "given a nil attribute or desired_value" do
       it "is false" do
-        expect(MatchAttributeValue.build_me?(rand.to_s, nil)).to be_falsey
-        expect(MatchAttributeValue.build_me?(nil, rand.to_s)).to be_falsey
-        expect(MatchAttributeValue.build_me?(nil, nil)).to be_falsey
+        allow(search_option).to receive(:attribute).and_return(rand.to_s)
+        allow(search_option).to receive(:desired_value).and_return(nil)
+        expect(MatchAttributeValue.build_me?(search_option)).to be_falsey
+
+        allow(search_option).to receive(:attribute).and_return(nil)
+        allow(search_option).to receive(:desired_value).and_return(rand.to_s)
+        expect(MatchAttributeValue.build_me?(search_option)).to be_falsey
+
+        allow(search_option).to receive(:attribute).and_return(nil)
+        allow(search_option).to receive(:desired_value).and_return(nil)
+        expect(MatchAttributeValue.build_me?(search_option)).to be_falsey
       end
     end
   end

data/spec/lib/query_string_search/matchers/match_multiple_attribute_values_spec.rb

@@ -5,20 +5,26 @@ RSpec.describe MatchMultipleAttributeValues do
   describe "match?" do
     it "matches if the target's attribute is one of the values" do
       target = SearchTarget.new(property: "1994")
-      matcher = MatchMultipleAttributeValues.new(:property, "1994|1995")
+      matcher = MatchMultipleAttributeValues.new
+      matcher.attribute = :property
+      matcher.desired_value = "1994|1995"
       expect(matcher.match?(target)).to be_truthy
     end
 
     it "does not match if the target's attribute is not one of the values" do
       target = SearchTarget.new(property: "199")
-      matcher = MatchMultipleAttributeValues.new(:property, "1994|1995")
+      matcher = MatchMultipleAttributeValues.new
+      matcher.attribute = :property
+      matcher.desired_value = "1994|1995"
       expect(matcher.match?(target)).to be_falsey
     end
 
     describe "if the target doesn't have the attribute" do
       it "is false" do
         target = SearchTarget.new(property: "1994")
-        subject = MatchAttribute.new(:bad_attr, "1994|1995")
+        matcher = MatchMultipleAttributeValues.new
+        matcher.attribute = :bad_attr
+        matcher.desired_value = "1994|1995"
 
         expect(subject.match?(target)).to be_falsey
       end
@@ -26,21 +32,29 @@ RSpec.describe MatchMultipleAttributeValues do
   end
 
   describe "build_me?" do
-    describe "given a search type and search param that contains a pipe" do
+    let(:search_option) { instance_double(QueryStringSearch::SearchOption) }
+
+    describe "given a search type and value that contains a pipe" do
       it "is true" do
-        expect(MatchMultipleAttributeValues.build_me?(rand, "x|y")).to be_truthy
+        allow(search_option).to receive(:attribute).and_return(rand.to_s)
+        allow(search_option).to receive(:desired_value).and_return("x|y")
+        expect(MatchMultipleAttributeValues.build_me?(search_option)).to be_truthy
       end
     end
 
-    describe "given a search type and search param that starts with a pipe" do
+    describe "given a search type and value that starts with a pipe" do
       it "is false" do
-        expect(MatchMultipleAttributeValues.build_me?(rand, "|x|y")).to be_falsey
+        allow(search_option).to receive(:attribute).and_return(rand.to_s)
+        allow(search_option).to receive(:desired_value).and_return("|x|y")
+        expect(MatchMultipleAttributeValues.build_me?(search_option)).to be_falsey
       end
     end
 
     describe "given a search type without a pipe" do
       it "is false" do
-        expect(MatchMultipleAttributeValues.build_me?(rand, "xy")).to be_falsey
+        allow(search_option).to receive(:attribute).and_return(rand.to_s)
+        allow(search_option).to receive(:desired_value).and_return("xy")
+        expect(MatchMultipleAttributeValues.build_me?(search_option)).to be_falsey
       end
     end
   end

data/spec/lib/query_string_search/matchers/match_no_attribute_spec.rb

@@ -5,63 +5,72 @@ RSpec.describe MatchNoAttribute do
   describe "match?" do
     describe "if the target's attribute is not nil" do
       let(:target) { SearchTarget.new(property: "search_value") }
-      let(:subject) { MatchNoAttribute.new(:property) }
 
       it "is false" do
-        expect(subject.match?(target)).to be_falsey
+        matcher = MatchNoAttribute.new
+        matcher.attribute = :property
+        expect(matcher.match?(target)).to be_falsey
       end
     end
 
     describe "if the target's attribute is true" do
       let(:target) { SearchTarget.new(property: true) }
-      let(:subject) { MatchNoAttribute.new(:property) }
 
       it "is true" do
-        expect(subject.match?(target)).to be_falsey
+        matcher = MatchNoAttribute.new
+        matcher.attribute = :property
+        expect(matcher.match?(target)).to be_falsey
       end
     end
 
     describe "if the target's attribute is false" do
       let(:target) { SearchTarget.new(property: false) }
-      let(:subject) { MatchNoAttribute.new(:property) }
 
       it "is true" do
-        expect(subject.match?(target)).to be_truthy
+        matcher = MatchNoAttribute.new
+        matcher.attribute = :property
+        expect(matcher.match?(target)).to be_truthy
       end
     end
 
     describe "if the target's attribute is nil" do
       let(:target) { SearchTarget.new(property: nil) }
-      let(:subject) { MatchNoAttribute.new(:property) }
 
       it "is true" do
-        expect(subject.match?(target)).to be_truthy
+        matcher = MatchNoAttribute.new
+        matcher.attribute = :property
+        expect(matcher.match?(target)).to be_truthy
       end
     end
 
     describe "if the target doesn't have the attribute" do
       let(:target) { SearchTarget.new(property: rand) }
-      let(:subject) { MatchNoAttribute.new(:bad_attr) }
 
       it "is false" do
-        expect(subject.match?(target)).to be_falsey
+        matcher = MatchNoAttribute.new
+        matcher.attribute = :bad_attr
+        expect(matcher.match?(target)).to be_falsey
       end
     end
   end
 
   describe "build_me?" do
-    describe "given a search param of 'none' or 'false'" do
+    let(:search_option) { instance_double(QueryStringSearch::SearchOption) }
+
+    describe "given a value of 'none' or 'false'" do
       it "is true" do
-        %w(none false).each do |search_param|
-          expect(MatchNoAttribute.build_me?(rand, search_param)).to be_truthy
+        %w(none false).each do |desired_value|
+          allow(search_option).to receive(:desired_value).and_return(desired_value)
+          expect(MatchNoAttribute.build_me?(search_option)).to be_truthy
         end
       end
     end
 
-    describe "given a search param that is not 'none' or 'false'" do
+    describe "given a value that is not 'none' or 'false'" do
       it "is false" do
-        %w(one falsey).each do |search_param|
-          expect(MatchNoAttribute.build_me?(rand, search_param)).to be_falsey
+        %w(one falsey).each do |desired_value|
+          allow(search_option).to receive(:desired_value).and_return(desired_value)
+          expect(MatchNoAttribute.build_me?(search_option)).to be_falsey
         end
       end
     end

data/spec/lib/query_string_search/search_option_spec.rb

@@ -0,0 +1,34 @@
+require_relative "../../../lib/query_string_search/search_option"
+
+RSpec.describe QueryStringSearch::SearchOption do
+  describe "new" do
+    describe "with equality operator" do
+      let(:equal_query) { "test=2" }
+
+      it "correctly splits the attribute, value and operator" do
+        equal_option = QueryStringSearch::SearchOption.new("test=2")
+        expect(equal_option.attribute).to eq(:test)
+        expect(equal_option.desired_value).to eq("2")
+        expect(equal_option.operator).to eq("=")
+      end
+    end
+
+    describe "with inequality operators" do
+      let(:less_than_query_string) { "test<1" }
+      let(:greater_than_or_equal_query) { "test>=2" }
+
+      it "correctly splits the attribute, value and operator" do
+        less_than = QueryStringSearch::SearchOption.new(less_than_query_string)
+        greater_or_equal = QueryStringSearch::SearchOption.new(greater_than_or_equal_query)
+
+        expect(less_than.attribute).to eq(:test)
+        expect(less_than.desired_value).to eq("1")
+        expect(less_than.operator).to eq("<")
+
+        expect(greater_or_equal.attribute).to eq(:test)
+        expect(greater_or_equal.desired_value).to eq("2")
+        expect(greater_or_equal.operator).to eq(">=")
+      end
+    end
+  end
+end

data/spec/lib/query_string_search/search_options_spec.rb

@@ -2,51 +2,32 @@ require_relative "../../../lib/query_string_search/search_options"
 
 RSpec.describe QueryStringSearch::SearchOptions do
   describe "parse" do
-    describe "with a single-element and multi-element query_string" do
-      let(:single_query_string) { "test=filter" }
-      let(:multi_query_string) { "test=filter,test2=test%20attribute" }
-      let(:single_element) { QueryStringSearch::SearchOptions.parse(single_query_string) }
-      let(:multi_element) { QueryStringSearch::SearchOptions.parse(multi_query_string) }
-
-      describe "returns a collection" do
-        it "that is enumerable" do
-          [single_element, multi_element].each do |it|
-            expect(it).to respond_to(:each)
-          end
-        end
-
-        describe "whose contents" do
-          it "have search_type that are symbols" do
-            expect(single_element.collect(&:search_type)).to eq([:test])
-            expect(multi_element.collect(&:search_type)).to eq([:test, :test2])
-          end
+    describe "with a single-element query_string" do
+      it "returns a collection of a single search option" do
+        option_double = Object.new
+        expect(QueryStringSearch::SearchOption).to receive(:new).with("test=filter").and_return(option_double)
+        expect(QueryStringSearch::SearchOptions.parse("test=filter")).to eq([option_double])
+      end
+    end
 
-          it "have search_param that are unescaped strings" do
-            expect(single_element.collect(&:search_param)).to eq(["filter"])
-            expect(multi_element.collect(&:search_param)).to eq(["filter", "test attribute"])
-          end
-        end
+    describe "with a multi-element query_string" do
+      let(:multi_query_string) { "test=filter,test2=test attribute" }
+      it "returns a collection of a multiple search options" do
+        option_double1 = Object.new
+        option_double2 = Object.new
+        expect(QueryStringSearch::SearchOption).to receive(:new).with("test=filter").and_return(option_double1)
+        expect(QueryStringSearch::SearchOption).to receive(:new).with("test2=test attribute").and_return(option_double2)
+        expect(QueryStringSearch::SearchOptions.parse(multi_query_string)).to eq([option_double1, option_double2])
       end
     end
 
     describe "with a nil" do
       let(:nil_element) { QueryStringSearch::SearchOptions.parse(nil) }
-      describe "returns a collection" do
-        it "that is enumerable" do
-          expect(nil_element).to respond_to(:each)
-        end
-
-        it "with one element" do
-          expect(nil_element.count).to eq(1)
-        end
-
-        it "with nil search_type" do
-          expect(nil_element.first.search_type).to be_nil
-        end
+      it "creates a collection with one nil search option" do
+        option_double = Object.new
+        expect(QueryStringSearch::SearchOption).to receive(:new).with(nil).and_return(option_double)
 
-        it "with nil search_param" do
-          expect(nil_element.first.search_param).to be_nil
-        end
+        expect(QueryStringSearch::SearchOptions.parse(nil)).to eq([option_double])
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: query_string_search
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Ian Whitney
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,21 +114,28 @@ files:
 - README.md
 - Rakefile
 - lib/query_string_search.rb
+- lib/query_string_search/abstract_comparison.rb
 - lib/query_string_search/abstract_matcher.rb
+- lib/query_string_search/comparison_factory.rb
+- lib/query_string_search/comparisons/inequality.rb
+- lib/query_string_search/comparisons/set.rb
 - lib/query_string_search/matcher_factory.rb
 - lib/query_string_search/matchers/match_all.rb
 - lib/query_string_search/matchers/match_attribute.rb
 - lib/query_string_search/matchers/match_attribute_value.rb
 - lib/query_string_search/matchers/match_multiple_attribute_values.rb
 - lib/query_string_search/matchers/match_no_attribute.rb
+- lib/query_string_search/search_option.rb
 - lib/query_string_search/search_options.rb
 - lib/query_string_search/search_parameters.rb
 - lib/query_string_search/version.rb
 - query_string_search.gemspec
 - spec/doubles/search_target.rb
 - spec/features/find_all_data_spec.rb
+- spec/features/find_records_by_searching_a_attribute_that_returns_a_collection_spec.rb
 - spec/features/find_records_that_match_multiple_parameters_spec.rb
 - spec/features/find_records_that_match_one_of_many_attributes_spec.rb
+- spec/features/find_records_with_inequality_matchers_spec.rb
 - spec/features/find_records_with_matching_attribute_values_spec.rb
 - spec/features/find_records_with_nil_attributes_spec.rb
 - spec/features/find_records_with_nonnil_attributes_spec.rb
@@ -141,6 +148,7 @@ files:
 - spec/lib/query_string_search/matchers/match_attribute_value_spec.rb
 - spec/lib/query_string_search/matchers/match_multiple_attribute_values_spec.rb
 - spec/lib/query_string_search/matchers/match_no_attribute_spec.rb
+- spec/lib/query_string_search/search_option_spec.rb
 - spec/lib/query_string_search/search_options_spec.rb
 - spec/lib/query_string_search/search_parameters_spec.rb
 - spec/spec_helper.rb
@@ -171,8 +179,10 @@ summary: Provides a standard way to do searches using query strings in an API en
 test_files:
 - spec/doubles/search_target.rb
 - spec/features/find_all_data_spec.rb
+- spec/features/find_records_by_searching_a_attribute_that_returns_a_collection_spec.rb
 - spec/features/find_records_that_match_multiple_parameters_spec.rb
 - spec/features/find_records_that_match_one_of_many_attributes_spec.rb
+- spec/features/find_records_with_inequality_matchers_spec.rb
 - spec/features/find_records_with_matching_attribute_values_spec.rb
 - spec/features/find_records_with_nil_attributes_spec.rb
 - spec/features/find_records_with_nonnil_attributes_spec.rb
@@ -185,6 +195,7 @@ test_files:
 - spec/lib/query_string_search/matchers/match_attribute_value_spec.rb
 - spec/lib/query_string_search/matchers/match_multiple_attribute_values_spec.rb
 - spec/lib/query_string_search/matchers/match_no_attribute_spec.rb
+- spec/lib/query_string_search/search_option_spec.rb
 - spec/lib/query_string_search/search_options_spec.rb
 - spec/lib/query_string_search/search_parameters_spec.rb
 - spec/spec_helper.rb