mundane-search 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mundane-search.gemspec
+gemspec
+
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Sam Schenkman-Moore
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,138 @@
+# MundaneSearch
+
+MundaneSearch aims to compartmentalize multi-step search.
+
+## Installation
+
+You know the deal:
+
+    gem 'mundane-search' # in your Gemfile, then "bundle"
+    # or just gem install mundane-search on your command line
+    require "mundane-search"
+
+## Usage
+
+Build a search using middleware, then run that search on a specific collection and params.
+
+Collections are typically array-like structures (arrays, ActiveRecord or Sunsport scoped collections, etc.)
+
+Params are hash-like structures, such as those interpreted from forms and query strings. They are optional.
+
+    built = MundaneSearch::Builder.new do
+      use MundaneSearch::Filters::ExactMatch, param_key: "fruit"
+    end
+    built.call %w(apple orange blueberry), { 'fruit' => 'orange' } # ["orange"]
+
+If you check out project, ./script/console will get you a session with everything loaded up.
+
+## Middleware
+
+Make your own filters! Here's how:
+
+    class MustContainVowel < MundaneSearch::Filters::Base
+      def filtered_collection
+        collection.select {|e| e =~ /[aeiouy]/i} # only elements that contain a vowel
+      end
+    end
+
+Then you can reference that filter when you build a search:
+
+    built = MundaneSearch::Builder.new do
+      use MustContainVowel
+    end
+    built.call %w(CA TX NY FL IL) # ['CA','NY','IL']
+
+Filters are more useful when they are reusable. Arguments passed after the filter name (use Filter, arguments) will be passed into the filter's constructer.
+The Base filter in these examples sets an "options" variable with this argument.
+
+    class MustMatch < MundaneSearch::Filters::Base
+      def filtered_collection
+        collection.select {|e| e.match(options[:regex]) }
+      end
+    end
+    built = MundaneSearch::Builder.new do
+      use MustMatch, regex: /\A[a-m]+\Z/i
+      use MustMatch, regex: /L/
+    end
+    built.call %w(CA TX NY FL IL) # ["FL", "IL"]
+
+Filters will often be configured to consider input on a specific search. So, you'd configure your filter to pull values from params to limit results.
+
+    class MatchIfNameEqual < MundaneSearch::Filters::Base
+      def filtered_collection
+        collection.select {|e| e == params[:name] }
+      end
+    end
+    built = MundaneSearch::Builder.new do
+      use MatchIfNameEqual
+    end
+    built.call %w(Bill Bush Barack), { name: "Bill" } # ["Bill"]
+
+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"]
+
+It also ignores empty params:
+
+    built = MundaneSearch::Builder.new do
+      use MundaneSearch::Filters::ExactMatch, param_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
+    end
+    built.call %w(Private Sergeant Lieutenant), { "title" => nil } # []
+
+You can alter params as well, in a similar fashion.
+
+    class AlwaysSearchingForGumbo < MundaneSearch::Filters::Base
+      def filtered_params
+        params.merge({ options[:param_key] => "Gumbo" })
+      end
+    end
+    built = MundaneSearch::Builder.new do
+      use AlwaysSearchingForGumbo, param_key: "food"
+      use MundaneSearch::Filters::ExactMatch, param_key: "food"
+    end
+    built.call %w(Pizza Pasta Antipasto Gumbo), { "food" => "Pizza" } # ["Gumbo"]
+    built.call %w(Pizza Pasta Antipasto Gumbo) # ["Gumbo"]
+
+So yeah, it's fun. Here's a more practical example ... if you have clients that pass in groups of empty parameters (intending for those to not influence the search) BlankParamsAreNil will turn those empty strings into nil values.
+
+    built = MundaneSearch::Builder.new do
+      use MundaneSearch::Filters::BlankParamsAreNil
+      use MundaneSearch::Filters::ExactMatch, param_key: "food"
+      use MundaneSearch::Filters::ExactMatch, param_key: "noms"
+    end
+    built.call %w(Pizza Pasta Antipasto Gumbo), { "food" => "", "noms" => "Gumbo" } # ["Gumbo"]
+
+## ActiveRecord
+
+MundaneSearch can work with any collection object that can be passed around and modified. Filters can be designed to work with several types of collection.
+
+    class OnlyManagers < MundaneSearch::Filters::Base
+      def filtered_collection
+        case collection
+        when ActiveRecord::Relation
+          collection.where(postion: "manager")
+        else
+          collection.select {|e| e.position == "manager" }
+        end
+      end
+    end
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,42 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+namespace 'test' do
+  test_files             = FileList['spec/**/*_spec.rb']
+  integration_test_files = FileList['spec/**/*_integration_spec.rb']
+  unit_test_files        = test_files - integration_test_files
+
+  desc "Run unit tests"
+  Rake::TestTask.new('unit') do |t|
+    t.libs.push "lib"
+    t.test_files = unit_test_files
+    t.verbose = false
+  end
+
+  desc "Run integration tests"
+  Rake::TestTask.new('integration') do |t|
+    t.libs.push "lib"
+    t.test_files = integration_test_files
+    t.verbose = false
+  end
+end
+
+namespace 'database' do
+  desc "Setup test database"
+  task :test_setup do
+    require './spec/active_record_setup'
+    ActiveRecord::Migration.create_table :books do |t|
+      t.string    :title
+      t.string    :author
+      t.date      :publication_date
+      t.timestamp :first_purchased_at
+      t.integer   :sold
+    end
+  end
+end
+
+#Rake::Task['test'].clear
+desc "Run all tests"
+task 'test' => %w[test:unit test:integration]
+task 'default' => 'test'

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rake', 'rake')

data/lib/mundane-search.rb

@@ -0,0 +1,9 @@
+require "mundane-search/version"
+require "mundane-search/builder"
+require "mundane-search/filter_canister"
+require "mundane-search/result"
+require "mundane-search/initial_result"
+require "mundane-search/filters"
+
+module MundaneSearch
+end

data/lib/mundane-search/builder.rb

@@ -0,0 +1,41 @@
+require_relative './filters'
+
+module MundaneSearch
+  class Builder
+    include MundaneSearch::Filters
+
+    def initialize(&block)
+      @use = []
+
+      instance_eval(&block) if block_given?
+    end
+
+    def use(filter, *args, &block)
+      @use << filter_canister.new(filter, *args, &block)
+    end
+
+    def filter_canister
+      FilterCanister
+    end
+
+    def filters
+      @use
+    end
+
+    def call(collection, params = {})
+      result = result_for(collection, params)
+      result.collection
+    end
+
+    def result_for(collection, params = {})
+      initial_result = InitialResult.new(collection, params)
+      filters.inject(initial_result) do |result, filter|
+        result.add_filter(filter)
+      end
+    end
+  end
+end
+
+
+
+

data/lib/mundane-search/filter_canister.rb

@@ -0,0 +1,12 @@
+module MundaneSearch
+  class FilterCanister
+    attr_reader :filter, :options
+    def initialize(filter, *args)
+      @filter, @options = filter, args
+    end
+
+    def call(collection, params)
+      filter.new(collection, params, *options).call
+    end
+  end
+end

data/lib/mundane-search/filters.rb

@@ -0,0 +1,12 @@
+module MundaneSearch
+  module Filters
+  end
+end
+
+require_relative 'filters/helpers'
+require_relative 'filters/base'
+require_relative 'filters/typical'
+require_relative 'filters/exact_match'
+require_relative 'filters/blank_params_are_nil'
+require_relative 'filters/attribute_match'
+

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

@@ -0,0 +1,14 @@
+module MundaneSearch::Filters
+  class AttributeMatch < Typical
+    def filtered_collection
+      case collection
+      when ActiveRecord::Relation
+        collection.where(param_key => params[param_key.to_s])
+      when :sunspot?
+        # nothing yet
+      else
+        collection.select {|e| e.send(param_key) == params[param_key.to_s] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module MundaneSearch::Filters
+  class Base
+    include Helpers
+    attr_reader :collection, :params, :options
+    def initialize(collection, params = {}, options= {})
+      @collection, @params, @options = collection, params, options
+    end
+
+    def apply?
+      true
+    end
+
+    def filtered_collection
+      collection
+    end
+
+    def filtered_params
+      params
+    end
+
+    def call
+      [filtered_collection, filtered_params]
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module MundaneSearch::Filters
+  class BlankParamsAreNil < Base
+    def filtered_params
+      params.inject({}) do |hash,e|
+        val = e.last
+        hash[e.first] = (val.nil? || val.empty?) ? nil : val
+        hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module MundaneSearch::Filters
+  class ExactMatch < Typical
+    def filtered_collection
+      if apply?
+        collection.select {|e| e == match_value }
+      else
+        collection
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module MundaneSearch::Filters::Helpers
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+    def optional_unless_required
+      include Optional
+    end
+
+    def optional_without_match_value
+      include OptionalWithoutMatchValue
+    end
+
+    def has_a_match_value
+      include MatchValue
+    end
+
+  end
+
+
+  module Optional
+    def optional?
+      options[:required]
+    end
+  end
+
+  module OptionalWithoutMatchValue
+    include Optional
+    def apply?
+      match_value || optional?
+    end
+  end
+
+  module MatchValue
+    def param_key
+      options.fetch(:param_key)
+    end
+
+    def match_value
+      params[param_key]
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module MundaneSearch::Filters
+  class Typical < Base
+    has_a_match_value
+    optional_without_match_value
+  end
+end

data/lib/mundane-search/initial_result.rb

@@ -0,0 +1,7 @@
+module MundaneSearch
+  class InitialResult < Result
+    def initialize(collection,params)
+      @collection, @params = collection, params
+    end
+  end
+end

data/lib/mundane-search/result.rb

@@ -0,0 +1,19 @@
+module MundaneSearch
+  class Result
+    include Enumerable
+    attr_reader :collection, :params, :previous_result
+    def initialize(previous_result, filter)
+      @previous_result = previous_result
+      @collection, @params = filter.call(previous_result.collection, previous_result.params)
+    end
+
+    def add_filter(filter)
+      Result.new(self,filter)
+    end
+
+    def each(*args, &block)
+      return enum_for(__callee__) unless block_given?
+      collection.each(*args, &block)
+    end
+  end
+end

data/lib/mundane-search/version.rb

@@ -0,0 +1,3 @@
+module MundaneSearch
+  VERSION = "0.0.1"
+end

data/mundane-search.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mundane-search/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "mundane-search"
+  gem.version       = MundaneSearch::VERSION
+  gem.authors       = ["Sam Schenkman-Moore"]
+  gem.email         = ["samsm@samsm.com"]
+  gem.description   = %q{Makes everyday search easy-ish.}
+  gem.summary       = %q{Makes everyday search easy-ish.}
+  gem.homepage      = "https://github.com/samsm/mundane-search"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "activerecord"
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "database_cleaner"
+end

data/script/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'rubygems'
+require 'bundler/setup'
+require 'mundane-search'
+
+begin
+  require 'pry'
+  Pry.start
+rescue LoadError
+  require 'irb'
+  IRB.start
+end

data/spec/active_record_setup.rb

@@ -0,0 +1,80 @@
+require 'rubygems'
+require 'active_record'
+require 'fileutils'
+
+FileUtils.mkdir_p "./tmp"
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => 'tmp/test.db'
+)
+
+require 'database_cleaner'
+DatabaseCleaner.strategy = :truncation
+
+class Book < ActiveRecord::Base
+  # t.string    :title
+  # t.string    :author
+  # t.date      :publication_date
+  # t.timestamp :first_purchased_at
+  # t.integer   :sold
+end
+
+
+def populate_books!
+  [
+    {
+      title: "A Tale of Two Cities",
+      author: "Charles Dickens",
+      publication_date: Date.parse('31-12-1859'),
+      first_purchased_at: Time.utc(1859,"jan",1,20,15,1),
+      sold: 200_000_000
+    },
+    {
+      title: "The Lord of the Rings",
+      author: "J. R. R. Tolkien",
+      publication_date: Date.parse('31-12-1954'),
+      first_purchased_at: Time.utc(1954,"jan",1,20,15,1),
+      sold: 150_000_000
+    },
+    {
+      title: "The Little Prince (Le Petit Prince)",
+      author: "Antoine de Saint-Exupery",
+      publication_date: Date.parse('31-12-1943'),
+      first_purchased_at: Time.utc(1943,"jan",1,20,15,1),
+      sold: 140_000_000
+    },
+    {
+      title: "The Hobbit",
+      author: "J. R. R. Tolkien",
+      publication_date: Date.parse('31-12-1937'),
+      first_purchased_at: Time.utc(1937,"jan",1,20,15,1),
+      sold: 100_000_000
+    },
+    {
+      title: "Hong lou meng (Dream of the Red Chamber/The Story of the Stone)",
+      author: "Cao Xueqin",
+      publication_date: Date.parse('31-12-1754'),
+      first_purchased_at: Time.utc(1754,"jan",1,20,15,1),
+      sold: 100_000_000
+    },
+    {
+      title: "And Then There Were None",
+      author: "Agatha Christie",
+      publication_date: Date.parse('31-12-1939'),
+      first_purchased_at: Time.utc(1939,"jan",1,20,15,1),
+      sold: 100_000_000
+    }
+  ].each do |book_hash|
+    Book.create(book_hash)
+  end
+end
+
+begin
+  Book.new
+rescue ActiveRecord::StatementInvalid
+  puts ''
+  puts "*****************************************************************"
+  puts "Run: rake database:test_setup to create a database for this test."
+  puts "*****************************************************************"
+  puts ''
+end

data/spec/builder_integration_spec.rb

@@ -0,0 +1,14 @@
+require_relative 'minitest_helper'
+
+describe MundaneSearch::Builder do
+  Builder = MundaneSearch::Builder
+
+  it "should limit results using exact match filter" do
+
+    built = Builder.new do
+      use MundaneSearch::Filters::ExactMatch, param_key: "foo"
+    end
+
+    built.call(collection, params).must_equal(['bar'])
+  end
+end

data/spec/builder_spec.rb

@@ -0,0 +1,25 @@
+require_relative 'minitest_helper'
+
+describe MundaneSearch::Builder do
+  Builder = MundaneSearch::Builder
+
+  let(:collection) { %w(foo bar baz)    }
+  let(:params)     { { 'foo' => 'bar' } }
+
+  describe "empty search" do
+    let(:builder) { Builder.new }
+
+    it "should return unchanged collection on call" do
+      builder.call(collection, params).must_equal(collection)
+    end
+  end
+
+  it "should use middleware" do
+    builder = Builder.new do
+      use NothingFilterForTest
+    end
+    canister = builder.filters.first
+    canister.must_be_kind_of MundaneSearch::FilterCanister
+    canister.filter.must_equal NothingFilterForTest
+  end
+end

data/spec/filters/attribute_match_integration_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../minitest_helper'
+require_relative '../active_record_setup'
+
+describe MundaneSearch::Filters::AttributeMatch do
+  before do
+    DatabaseCleaner.clean
+    populate_books!
+  end
+
+  let(:all_books) { Book.scoped }
+  let(:a_tale_of_two_cities) { Book.first }
+
+  it "should something" do
+    built = Builder.new do
+      use MundaneSearch::Filters::AttributeMatch, param_key: "author"
+    end
+
+    built.call(all_books, {"author" => "Charles Dickens"}).must_equal([a_tale_of_two_cities])
+  end
+end

data/spec/filters/base_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../minitest_helper'
+
+describe MundaneSearch::Filters::Base do
+  Base = MundaneSearch::Filters::Base
+
+  let(:collection) { %w(foo bar baz)    }
+  let(:params)     { { 'foo' => 'bar' } }
+
+  it "should pass through" do
+    base = Base.new(collection, params)
+    base.call.must_equal [collection, params]
+  end
+end

data/spec/filters/exact_match_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../minitest_helper'
+
+describe MundaneSearch::Filters::ExactMatch do
+  ExactMatch = MundaneSearch::Filters::ExactMatch
+
+  let(:collection) { %w(foo bar baz)    }
+  let(:params)     { { 'foo' => 'bar' } }
+
+  it "should only take effect if matching param is avilable" do
+    options = { param_key: 'unmatched' }
+    em = ExactMatch.new(collection, params, options)
+    coll, parms = em.call
+    coll.must_equal(collection)
+  end
+
+  it "should match equivalent element" do
+    options = { param_key: 'foo' }
+    em = ExactMatch.new(collection, params, options)
+    coll, parms = em.call
+    coll.must_equal(['bar'])
+  end
+end

data/spec/filters_spec.rb

@@ -0,0 +1,9 @@
+require_relative 'minitest_helper'
+
+describe MundaneSearch::Filters do
+  Filters = MundaneSearch::Filters
+
+  it "should be a module" do
+    Filters.must_be_kind_of Module
+  end
+end

data/spec/minitest_helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+gem 'minitest' # ensures you're using the gem, and not the built in MT
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/mock'
+
+require 'mundane-search'
+require 'pry' rescue nil
+
+class NothingFilterForTest
+  def initialize(a=nil) ; end
+  def call(c,p) ; [c,p] ; end
+end
+
+def collection
+  %w(foo bar baz)
+end
+
+def params
+  { 'foo' => 'bar' }
+end

data/spec/result_spec.rb

@@ -0,0 +1,35 @@
+require_relative 'minitest_helper'
+
+describe "results" do
+  let(:collection) { %w(foo bar baz)    }
+  let(:params)     { { 'foo' => 'bar' } }
+  let(:initial)    { MundaneSearch::InitialResult.new(collection, params) }
+
+  describe MundaneSearch::InitialResult do
+    InitialResult = MundaneSearch::InitialResult
+    it "should take a collection and params" do
+      initial.must_be_kind_of InitialResult
+    end
+  end
+
+  describe MundaneSearch::Result do
+    Result = MundaneSearch::Result
+
+    let(:result) { Result.new(initial, filter) }
+    let(:filter) { NothingFilterForTest.new    }
+
+    it "should show collection" do
+      result.collection.must_equal collection
+    end
+
+    it "should show params" do
+      result.params.must_equal params
+    end
+
+    it "should be iterateable" do
+      result.first.must_equal collection.first
+      result.count.must_equal collection.count
+    end
+  end
+
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: mundane-search
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sam Schenkman-Moore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Makes everyday search easy-ish.
+email:
+- samsm@samsm.com
+executables:
+- rake
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/rake
+- lib/mundane-search.rb
+- lib/mundane-search/builder.rb
+- lib/mundane-search/filter_canister.rb
+- lib/mundane-search/filters.rb
+- lib/mundane-search/filters/attribute_match.rb
+- lib/mundane-search/filters/base.rb
+- lib/mundane-search/filters/blank_params_are_nil.rb
+- lib/mundane-search/filters/exact_match.rb
+- lib/mundane-search/filters/helpers.rb
+- lib/mundane-search/filters/typical.rb
+- lib/mundane-search/initial_result.rb
+- lib/mundane-search/result.rb
+- lib/mundane-search/version.rb
+- mundane-search.gemspec
+- script/console
+- spec/active_record_setup.rb
+- spec/builder_integration_spec.rb
+- spec/builder_spec.rb
+- spec/filters/attribute_match_integration_spec.rb
+- spec/filters/attribute_match_spec.rb
+- spec/filters/base_spec.rb
+- spec/filters/exact_match_spec.rb
+- spec/filters_spec.rb
+- spec/minitest_helper.rb
+- spec/result_spec.rb
+homepage: https://github.com/samsm/mundane-search
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1695916401118151640
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1695916401118151640
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Makes everyday search easy-ish.
+test_files:
+- spec/active_record_setup.rb
+- spec/builder_integration_spec.rb
+- spec/builder_spec.rb
+- spec/filters/attribute_match_integration_spec.rb
+- spec/filters/attribute_match_spec.rb
+- spec/filters/base_spec.rb
+- spec/filters/exact_match_spec.rb
+- spec/filters_spec.rb
+- spec/minitest_helper.rb
+- spec/result_spec.rb