query_string_search 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d98152d90936269401df2e71217c03c41c5f249a
-  data.tar.gz: b9d1b39ecfb46a0fbc15816e849575c30970e571
+  metadata.gz: 9ac9f7da9d9c53692c3ccb4e3c7fab60ba524d1f
+  data.tar.gz: 865d14548d4ed0aa2129b759f127b8b808d7121d
 SHA512:
-  metadata.gz: 731af57376be5e8859edc378c5d2c3b6c41196ae88c4bda918ca0f973713fb5bfcc1a6f3d0844977deca202b278c74219341a48545bce9fc08250e9195e29bbf
-  data.tar.gz: 4c1a8a92387aeb3390f4a46a0b40746b2dcc031b9586bbe0138dbce930e6360cb62d906f17b013006549580216bdf05e7d38b1f8267f0c37cd7d79c10ad48134
+  metadata.gz: 502464cf14160e106a69ccaa6b671db44650980c6db6e91acba6b5fe39f7e11aa28d70e1b04b0d657829ddf8c90df858aef79703e9f5c0148ea5478034f73407
+  data.tar.gz: fe7f411d65369fb73ec21f2cd15883149a47ae357fdb74d74eaf182f26c9988402f8ba5b453f7cbbe3032fe504842431a8aa12dfd3dbb217367ac41d6134264a

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
+cache: bundler
 rvm:
 - 2.1.5
 - 2.2.0

data/README.md

@@ -1,84 +1,59 @@
-# Query String Search [![Build Status](https://api.travis-ci.org/umn-asr/query_string_search.svg?branch=master)](https://travis-ci.org/umn-asr/query_string_search) [![Code Climate](https://codeclimate.com/github/umn-asr/query_string_search/badges/gpa.svg)](https://codeclimate.com/github/umn-asr/query_string_search)
+# Query String Search 
+[![Build Status](https://api.travis-ci.org/umn-asr/query_string_search.svg?branch=master)](https://travis-ci.org/umn-asr/query_string_search) 
+[![Code Climate](https://codeclimate.com/github/umn-asr/query_string_search/badges/gpa.svg)](https://codeclimate.com/github/umn-asr/query_string_search)
+[![Gem Version](https://badge.fury.io/rb/query_string_search.svg)](http://badge.fury.io/rb/query_string_search)
 
-Provides an easy way to implement searching in your API endpoints
+Provides an easy way to implement searching in your API endpoints.
 
 ## Searches it supports
 
-Say you have a `movies` endpoint and people want to be able to search your huge collection of movie data. The API Search gem will give you the following search functionality:
-
-### Return all data
-
-`movies` will return every movie in the data set.
-
-### Return all data with non-null attribute value
-
-`movies?q=rating=all`
-
-Returns every movie with a non-nil rating.
-
-### Return all data with null attribute value
-
-`movies?q=rating=none`
-
-Returns every movie without ratings.
-
-### Return all data with an attribute value that matches
-
-`movies?q=year=1994`
-
-Returns every movie with a year of 1994
-
-### Return all data that matches one of many attributes
-
-`movies?q=year=1994|1995`
-
-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"
+Say you have a `movies` endpoint and people want to be able to search your huge collection of movie data. Each of your movies have these properties
+
+- Rating: returns "PG", "R", etc. Can also return nil
+- Year: returns the year the film was released
+- Title: The movie's title
+- Star Rating: returns a number 1 to 5
+- Home Formats: returns an array of available home formats. `["DVD", "BD"]`, for example.
+
+The API Search gem will give you the following search functionality:
+
+Query String Example  | What Data is Returned
+------------- | -------------
+`movies` | All data in your data set
+`movies?q=rating=all` | Movies with a non-nil rating
+`movies?q=rating=none` | Movies with a nil rating
+`movies?q=year=1994` | Movies with a year of 1994
+`movies?q=year=1994|1995` | Movies with a year of 1994 or 1995
+`movies?q=title=Dunston%20Checks%20In` | Movies with the title Dunston Checks In
+`movies?q=star_rating>1` | Movies with a star rating greater than one
+`movies?q=star_rating<3` | Movies with a star rating less than three
+`movies?q=star_rating>=2` | Movies with a star rating greater than or equal to 2
+`movies?q=star_rating<=4` | Movies with a star rating less than or equal to 4
+`movies?q=home_formats=DVD` | Movies that are available on DVD.
+`movies?q=home_formats=DVD|BD` | Movies that are available on DVD or Blu Ray
 
 ### Combining Searches
 
-Search criteria can be separated with commas
+Any of the above critera can be combined. 
+Just separate criteria with commas. 
+Records that match **all** the criteria will be returned. 
+Some examples!
 
-`movie?q=year=1994,country=US,rated=none`
+`movie?q=year=1994,country=US,rated=none`<br />
+ All un-rated movies made in the US in 1994.
 
-Records that match **all** the criteria will be returned. All un-rated movies made in the US in 1994.
+`movie?q=home_formats=BD|DVD,rated=R|PG,star_rating>3`<br />
+All movies available on BD or DVD, that are rated R or PG, and that have a star rating greater than 3
 
-## Installation
+## Use Cases
 
-Add this line to your application's Gemfile:
+This gem fits best when you're trying to provide very flexible searching on a relatively small and flat set of data. Because it filters a data set that you provide, the speed at which it works is wholly dependent on the size of your data set.
 
-```ruby
-gem 'query_string_search'
-```
+We currently use this gem on a small (~2000 rows) data set which is cached in memory. Response times using Rails/Passenger/Apache are always under 100ms, usually under 50ms. That's plenty fast! But if your initial data set is massive, or you can't cache it, your response times will be slower. Such is life. Gems like [Periscope](https://rubygems.org/gems/periscope) or [has_scope](https://rubygems.org/gems/has_scope) may be more your speed.
 
-And then execute:
+A downside of gems like those, though, is that you end up defining all of your filtering methods in advance. This is not the case with Query String Search. If the elements in your data set respond to a method, then the data can be filtered by the return value of that method. It is possible that this is not what you want. In which case, check out those other gems. Or, you could also wrap your object instances in a wrapper that only responds to the methods that you want to filter on.
 
-    $ bundle
+Also, this gem is platform and persistence agnostic. Rails? Sinatra? Cuba? Redis? Postgres? Doesn't matter. You pass it objects, it filters them down based on the query string.
 
 ## Usage
 
@@ -90,20 +65,20 @@ Movie.all
 
 Or something similar. As long as it returns a collection of objects, you should be good.
 
-The objects must respond to the attributes you want to search on. Say you want to allow a search string like this:
+The objects must respond to the methods you want to search on. Say you want to allow a search string like this:
 
-```
 `movies?q=year=1994`
-```
 
 Then every object in your data collection needs to respond to `year`.
 
-Again, with ActiveRecord this is pretty straightforward. But if you're building your data source from raw SQL then you're going to have to convert that data into objects that respond to the attributes you want to search on.
-
 Second, search! In Rails you can do something like this in a Controller method.
 
 ```ruby
-QueryStringSearch.new(data, query_string).results
+def index
+  query_string = params[:q]
+  QueryStringSearch.new(Movie.all, query_string).results
+  #....
+end
 ```
 
 This returns a collection of the objects that matched the search criteria.
@@ -111,12 +86,23 @@ This returns a collection of the objects that matched the search criteria.
 Or you can do it not in the controller. This will work:
 
 ```ruby
-test_query = "country=us"
-QueryStringSearch.new(Movie.all, test_query).results
+QueryStringSearch.new(Movie.all, "country=us").results
 ```
 
 You get the idea. Pass in a data set and a query-stringish string and you'll get results back.
 
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'query_string_search'
+```
+
+And then execute:
+
+    $ bundle
+
 
 ## Contributing
 

data/lib/query_string_search/matchers/match_attribute.rb

@@ -1,6 +1,9 @@
 class MatchAttribute < QueryStringSearch::AbstractMatcher
   def match?(data)
-    match_with_contingency { actual_value(data) }
+    match_with_contingency do
+      actual_value(data) == true ||
+        Array(actual_value(data)).any?
+    end
   end
 
   def self.reserved_words

data/lib/query_string_search/matchers/match_no_attribute.rb

@@ -1,6 +1,9 @@
 class MatchNoAttribute < QueryStringSearch::AbstractMatcher
   def match?(data)
-    match_with_contingency { !actual_value(data) }
+    match_with_contingency do
+      actual_value(data) == false ||
+        Array(actual_value(data)).empty?
+    end
   end
 
   def self.reserved_words

data/lib/query_string_search/version.rb

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

data/spec/features/find_records_by_searching_a_attribute_that_returns_a_collection_spec.rb

@@ -6,6 +6,8 @@ RSpec.describe "Finding data based on an attribute that returns a collection" do
 
   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") } }
+  let(:movies_with_home_format) { data_set.select { |d| d.home_formats.any? } }
+  let(:movies_without_home_format) { data_set.select { |d| d.home_formats.none? } }
 
   it "Returns the correct records when searching for one value" do
     query_string = "home_formats=DVD"
@@ -20,4 +22,18 @@ RSpec.describe "Finding data based on an attribute that returns a collection" do
 
     expect(results).to eq(movies_on_dvd_or_bd)
   end
+
+  it "Returns the correct records when searching for all" do
+    query_string = "home_formats=#{ %w(all true).sample }"
+    results = QueryStringSearch.new(data_set, query_string).results
+
+    expect(results).to eq(movies_with_home_format)
+  end
+
+  it "Returns the correct records when searching for none" do
+    query_string = "home_formats=#{ %w(none false).sample }"
+    results = QueryStringSearch.new(data_set, query_string).results
+
+    expect(results).to eq(movies_without_home_format)
+  end
 end

data/spec/fixtures/movie.rb

@@ -16,7 +16,7 @@ class Movie
     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)
+    self.home_formats = %w(BD DVD Hulu Amazon Netflix).sample(rand(2))
   end
 
   def seen?

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

@@ -23,6 +23,16 @@ RSpec.describe MatchAttribute do
       end
     end
 
+    describe "if the target's attribute returns a collection" do
+      let(:target) { SearchTarget.new(property: %w(a b c)) }
+
+      it "is true" do
+        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) }
 
@@ -36,7 +46,7 @@ RSpec.describe MatchAttribute do
     describe "if the target's attribute is false" do
       let(:target) { SearchTarget.new(property: false) }
 
-      it "is true" do
+      it "is false" do
         matcher = MatchAttribute.new
         matcher.attribute = :property
         expect(matcher.match?(target)).to be_falsey

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

@@ -23,6 +23,16 @@ RSpec.describe MatchNoAttribute do
       end
     end
 
+    describe "if the target's attribute returns a collection" do
+      let(:target) { SearchTarget.new(property: %w(a b c)) }
+
+      it "is false" do
+        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) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: query_string_search
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Ian Whitney
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-23 00:00:00.000000000 Z
+date: 2015-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler