mundane-search 0.0.3 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 213f6117e16f7a6fec072526aef10e279d24ae2a
+  data.tar.gz: b1ec7d3a1abba8e2448cc1527c5d5cc627a62a72
+SHA512:
+  metadata.gz: f7ce9b6b8f7453100015b010cb5d21a78d1d2b00aa658d5d0e58224b905250a05a85776438e4f9158d1b673c203b4854fc41217e76b69c2042761a6fa4bf02a7
+  data.tar.gz: 41958041eba6222f5a5c318a13028b9eb3c88fca5cb4fd8d76ea7e3e4d7010993fe8d79472451d5a0d83c3681cc2e900ed49d329891ff15f872f4cb031ef7cb4

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -15,4 +15,7 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-.rvmrc
+.rvmrc
+.ruby-gemset
+.ruby-version
+bin/*

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+before_script:
+  - rake database:test_setup

data/Gemfile

@@ -3,4 +3,7 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in mundane-search.gemspec
 gemspec
 
-gem 'pry'
+gem 'pry'
+
+gem 'simplecov', :require => false, :group => :test
+gem 'coveralls', :require => false, :group => :test

data/README.md

@@ -1,5 +1,7 @@
 # MundaneSearch
 
+[![Gem Version](https://badge.fury.io/rb/mundane-search.png)](http://badge.fury.io/rb/mundane-search) [![Code Climate](https://codeclimate.com/github/samsm/mundane-search.png)](https://codeclimate.com/github/samsm/mundane-search) [![Coverage Status](https://coveralls.io/repos/samsm/mundane-search/badge.png?branch=master)](https://coveralls.io/r/samsm/mundane-search?branch=master) [![Dependency Status](https://gemnasium.com/samsm/mundane-search.png)](https://gemnasium.com/samsm/mundane-search)
+
 MundaneSearch aims to compartmentalize multi-step search.
 
 ## Installation
@@ -28,7 +30,7 @@ Create a search:
 Add filters to it:
 
     class BookSearch < MundaneSearch::Result
-      use :attribute_match, param_key: "title"
+      use :attribute_match, key: "title"
     end
 
 Then use that search in your controllers:
@@ -81,11 +83,11 @@ Three ways to notate filters:
 
 First some options that are common to many filters.
 
-* param_key: The key in params to examine for a matching value.
-* target: The attribute to match against. By default, uses param_key.
-* match_value: Usually nil. When nil, the value of params[param_key] is used.
+* key: The key in params to examine for a matching value.
+* target: The attribute to match against. By default, uses key.
+* match_value: Usually nil. When nil, the value of params[key] is used.
 * required: Default false. When true, will run a filter even if (for example) the match_value is nil.
-* type: Gives form helpers et al a hint as to what type the match_value should be. Overrides class method param_key_type in a filter.
+* type: Gives form helpers et al a hint as to what type the match_value should be. Overrides class method key_type in a filter.
   Available types:
   1. :string
   2. :integer
@@ -98,49 +100,61 @@ All those suckers in action:
     class BookSearch < MundaneSearch::Result
       # book.publisher == params["publisher"] even if the match_value (params["publisher"]) is nil
       # (in below examples, the filter is skipped if the match_value is nil)
-      use :attribute_match, param_key: "publisher", required: true
+      use :attribute_match, key: "publisher", required: true
 
       # book.title == params["title"]
-      use :attribute_match, param_key: "title"
+      use :attribute_match, key: "title"
 
       # book.author == params["writer"]
-      use :attribute_match, param_key: "writer", target: "author"
+      use :attribute_match, key: "writer", target: "author"
 
       # book.publication_date > Date.parse("1900-01-01") (disregards params)
-      use :operator, param_key: "publication_date", operator: :>, match_value: Date.parse("1900-01-01")
+      use :operator, key: "publication_date", operator: :>, match_value: Date.parse("1900-01-01")
 
       # simple_form displays filter as designated type
-      use :attribute_match, param_key: "first_purchased_at", type: :time
+      use :attribute_match, key: "first_purchased_at", type: :time
     end
 
 ### AttributeMatch
 
 Returns objects that exactly match an attribute, ex: book.title == "A Tale of Two Cities"
 
-    use :attribute_match, param_key: "title"
+    use :attribute_match, key: "title"
 
 ### AttributeSubstring
 
 Returns objects that match a portion of an attribute, ex: book.title =~ /Tale of/
 
-    use :attribute_substring, param_key: title
+    use :attribute_substring, key: title
 
 ### Operator
 
 Returns objects that match an attribute + operator, ex: book.publication_date > Date.parse("1900-01-01")
 
-Requires a param_key and a symbol of an operator (:>, :<, :>=, :<=)
+Requires a key and a symbol of an operator (:>, :<, :>=, :<=)
 
-    use :operator, param_key: "publication_date", operator: :>
+    use :operator, key: "publication_date", operator: :>
 
 ### Order
 
 Sorts a collection.
 
-    use :order, param_key: "sort", direction: "asc"
+    use :order, key: "sort", direction_key: "bearing"
+    # { "sort" => "publication_date", "bearing" => "descending" }
+
+### MultiOrder
+
+Sorts a collection based on several fields.
 
+    # Compact syntax:
+    use :multi_order, key: "sort"
+    # { "sort" => "sold;author:desc" }
 
-#### ExactMatch
+    # Array syntax (better for forms, maybe?)
+    use :multi_order, key: "sort", direction_key: "bearing"
+    # {"sort" => ["sold","author"], "bearing" => ["asc", "desc"]},
+
+### ExactMatch
 
 MundaneSearch can also work with objects that aren't "attribute-y".
 
@@ -157,7 +171,7 @@ Changes values of "", [], or {} to nil in params.
 MundaneSearch can be used outside of Rails on whatever sort of object you want:
 
     built = MundaneSearch::Builder.new do
-      use MundaneSearch::Filters::ExactMatch, param_key: "fruit"
+      use MundaneSearch::Filters::ExactMatch, key: "fruit"
     end
     built.call %w(apple orange blueberry), { 'fruit' => 'orange' } # ["orange"]
 
@@ -209,22 +223,22 @@ Filters will often be configured to consider input on a specific search. So, you
 This is another filter that would be more useful if instead of being hard-wired to look at params[:name], it could be configured when it is used.
 A supplied filter: ExactMatch, does just this.
 
-built = MundaneSearch::Builder.new do
-  use MundaneSearch::Filters::ExactMatch, param_key: "title"
-end
-built.call %w(Private Sergeant Lieutenant), { "title" => "Sergeant" } # ["Sergeant"]
+    built = MundaneSearch::Builder.new do
+      use MundaneSearch::Filters::ExactMatch, key: "title"
+    end
+    built.call %w(Private Sergeant Lieutenant), { "title" => "Sergeant" } # ["Sergeant"]
 
 It also ignores empty params:
 
     built = MundaneSearch::Builder.new do
-      use MundaneSearch::Filters::ExactMatch, param_key: "title"
+      use MundaneSearch::Filters::ExactMatch, key: "title"
     end
     built.call %w(Private Sergeant Lieutenant), { "title" => nil } # ["Private", "Sergeant", "Lieutenant"]
 
 Unless you tell it not to (in the following case, the filter will look for an exact match on nil, and not find it):
 
     built = MundaneSearch::Builder.new do
-      use MundaneSearch::Filters::ExactMatch, param_key: "title", required: true
+      use MundaneSearch::Filters::ExactMatch, key: "title", required: true
     end
     built.call %w(Private Sergeant Lieutenant), { "title" => nil } # []
 
@@ -232,12 +246,12 @@ You can alter params as well, in a similar fashion.
 
     class AlwaysSearchingForGumbo < MundaneSearch::Filters::Base
       def filtered_params
-        params.merge({ options[:param_key] => "Gumbo" })
+        params.merge({ options[:key] => "Gumbo" })
       end
     end
     built = MundaneSearch::Builder.new do
-      use AlwaysSearchingForGumbo, param_key: "food"
-      use MundaneSearch::Filters::ExactMatch, param_key: "food"
+      use AlwaysSearchingForGumbo, key: "food"
+      use MundaneSearch::Filters::ExactMatch, key: "food"
     end
     built.call %w(Pizza Pasta Antipasto Gumbo), { "food" => "Pizza" } # ["Gumbo"]
     built.call %w(Pizza Pasta Antipasto Gumbo) # ["Gumbo"]
@@ -246,8 +260,8 @@ So yeah, it's fun. Here's a more practical example ... if you have clients that
 
     built = MundaneSearch::Builder.new do
       use MundaneSearch::Filters::BlankParamsAreNil
-      use MundaneSearch::Filters::ExactMatch, param_key: "food"
-      use MundaneSearch::Filters::ExactMatch, param_key: "noms"
+      use MundaneSearch::Filters::ExactMatch, key: "food"
+      use MundaneSearch::Filters::ExactMatch, key: "noms"
     end
     built.call %w(Pizza Pasta Antipasto Gumbo), { "food" => "", "noms" => "Gumbo" } # ["Gumbo"]
 
@@ -258,8 +272,8 @@ If a filter is defined directly under MundaneSearch::Filters or Object (such as
 The following two "use" designations would use the same filter.
 
     MundaneSearch::Builder.new do
-      use MundaneSearch::Filters::ExactMatch, param_key: "foo"
-      use :exact_match, param_key: "foo"
+      use MundaneSearch::Filters::ExactMatch, key: "foo"
+      use :exact_match, key: "foo"
     end
 
 Object is searched first, so a user defined ExactMatch would take precedence over the MundaneSearch::Filters one.

data/Rakefile

@@ -20,6 +20,13 @@ namespace 'test' do
     t.test_files = integration_test_files
     t.verbose = false
   end
+
+  desc "Run all tests"
+  Rake::TestTask.new('all') do |t|
+    t.libs.push "lib"
+    t.test_files = test_files
+    t.verbose = false
+  end
 end
 
 namespace 'database' do
@@ -38,5 +45,5 @@ end
 
 #Rake::Task['test'].clear
 desc "Run all tests"
-task 'test' => %w[test:integration test:unit]
+task 'test' => %w[test:all]
 task 'default' => 'test'

data/lib/mundane-search.rb

@@ -1,4 +1,4 @@
-require "columns_hash"
+require "attribute_column"
 
 require 'mundane-search/railtie' if defined?(Rails)
 
@@ -14,4 +14,5 @@ module MundaneSearch
   autoload :Buildable, "mundane-search/buildable"
   autoload :Railtie, "mundane-search/railtie"
   autoload :ViewHelpers, "mundane-search/view_helpers"
+  autoload :ParamKeyTypes, "mundane-search/param_key_types"
 end

data/lib/mundane-search/filter_canister.rb

@@ -15,22 +15,15 @@ module MundaneSearch
       varient ? filter.const_get(varient) : filter
     end
 
-    def param_key
-      single_options[:param_key]
-    end
-
-    def param_key_type
-      single_options[:param_key_type] || param_key_type_from_filter
+    def option_keys_with_types
+      ParamKeyTypes.new(single_options, filter).pairs
     end
 
     private
     def single_options
       options.first || {}
     end
-
-    def param_key_type_from_filter
-      filter.param_key_type if filter.respond_to?(:param_key_type)
-    end
-
   end
 end
+
+

data/lib/mundane-search/filters/attribute_match.rb

@@ -2,12 +2,12 @@ module MundaneSearch::Filters
   class AttributeMatch < Typical
     class ActiveRecord < self
       def filtered_collection
-        collection.where(param_key => params[param_key.to_s])
+        collection.where(target => match_value)
       end
     end
 
     def filtered_collection
-      collection.select {|e| e.send(param_key) == params[param_key.to_s] }
+      collection.select {|e| e.send(target) == match_value }
     end
   end
 end

data/lib/mundane-search/filters/attribute_substring.rb

@@ -2,13 +2,12 @@ module MundaneSearch::Filters
   class AttributeSubstring < Typical
     class ActiveRecord < self
       def filtered_collection
-        # collection.where(param_key => params[param_key.to_s])
-        collection.where(["#{target} LIKE ?", "%#{params[param_key.to_s]}%"])
+        collection.where(["#{target} LIKE ?", "%#{match_value}%"])
       end
     end
 
     def filtered_collection
-      collection.select {|e| e.send(target).index(params[param_key.to_s]) }
+      collection.select {|e| e.send(target).index(match_value) }
     end
   end
 end

data/lib/mundane-search/filters/multi_order.rb

@@ -0,0 +1,78 @@
+module MundaneSearch::Filters
+  class MultiOrder < Typical
+
+    class ActiveRecord < self
+      def filtered_collection
+        collection.order(order_string)
+      end
+
+      private
+      def order_string
+        # puts
+        # puts "*** This requires escaping! ***"
+
+        statement = ordering_pairs.to_a.collect {|p| p.join(" ") }.join(", ")
+        escape_for_order_sql statement
+      end
+
+      def escape_for_order_sql(unescaped)
+        # This is crude, but agressive. Should workd for order statements.
+        # Escapes everything but [a-zA-Z0-9_,.] and whitespace
+        unescaped[/[.,\w\s]+/]
+      end
+    end
+
+    def filtered_collection
+      collection.reverse.sort do |a,b|
+        compare = ordering_pairs.inject([[],[]]) do |sum, pair|
+          attribute, direction = pair
+          attribute = :"#{attribute}"
+          if ascending_terms.include?(direction)
+            sum.first << a.send(attribute)
+            sum.last  << b.send(attribute)
+          else
+            sum.first << b.send(attribute)
+            sum.last  << a.send(attribute)
+          end
+          sum
+        end
+        compare.first <=> compare.last
+      end
+    end
+
+    private
+
+    def ordering_pairs
+      if match_value.kind_of?(String)
+        match_value.split(";").inject({}) do |hsh, pair|
+          key, val = pair.split(":")
+          hsh[key] = val || "asc"
+          hsh
+        end
+      else
+        Hash[keys_to_sort_on.zip(corresponding_directions_to_sort)]
+      end
+    end
+
+    def directions_key
+      options[:directions_key] || "directions"
+    end
+    def keys_to_sort_on
+      match_value
+    end
+
+    def corresponding_directions_to_sort
+      params[directions_key]
+    end
+
+    # These are duplicated in MultiOrder
+    def ascending_terms
+      %w(asc ascending <)
+    end
+
+    def descending_terms
+      %w(desc descending >)
+    end
+
+  end
+end

data/lib/mundane-search/filters/operator.rb

@@ -2,12 +2,12 @@ module MundaneSearch::Filters
   class Operator < Typical
     class ActiveRecord < self
       def filtered_collection
-        collection.where(["#{target} #{operator} ?", params[param_key.to_s]])
+        collection.where(["#{target} #{operator} ?", match_value])
       end
     end
 
     def filtered_collection
-      collection.select {|e| e.send(target).send(operator, params[param_key.to_s]) }
+      collection.select {|e| e.send(target).send(operator, match_value) }
     end
 
     def operator

data/lib/mundane-search/filters/order.rb

@@ -5,14 +5,15 @@ module MundaneSearch::Filters
         collection.order("#{match_value} #{active_record_direction}")
       end
 
+      private
       def active_record_direction
         direction || "ASC"
       end
     end
 
     def filtered_collection
-      collection.sort_by(&:"#{match_value}")
-      backwards? ? collection.reverse : collection
+      sorted = collection.sort_by(&:"#{match_value}")
+      backwards? ? sorted.reverse : sorted
     end
 
     protected
@@ -21,9 +22,14 @@ module MundaneSearch::Filters
     end
 
     def direction
-      params["direction"] || options[:direction]
+      options[:direction] || params[direction_key]
     end
 
+    def direction_key
+      options[:direction_key] || "direction"
+    end
+
+    # These are duplicated in MultiOrder
     def ascending_terms
       %w(asc ascending <)
     end

data/lib/mundane-search/filters/typical.rb

@@ -1,11 +1,16 @@
 module MundaneSearch::Filters
   class Typical < Base
-    def self.param_key_type
-      :string # common default
+    def self.key_types
+      { key: key_type }
+    end
+
+    def self.key_type
+      # common default
+      :string
     end
 
     def target
-      options[:target] || param_key
+      options[:target] || key
     end
 
     def optional?
@@ -16,17 +21,16 @@ module MundaneSearch::Filters
       match_value || optional?
     end
 
-    def param_key
-      options.fetch(:param_key)
+    def key
+      options.fetch(:key)
     end
 
     def match_value
-      options[:match_value] || params[param_key]
+      options[:match_value] || params[key]
     end
 
-    # This is a duplicate of the class method?
-    def param_key_type
-      options[:type] || self.class.param_key_type
+    def key_type
+      options[:type] || self.class.key_type
     end
   end
 end