searchlight 3.1.1 → 4.0.0

data/lib/searchlight/options.rb

@@ -0,0 +1,27 @@
+module Searchlight::Options
+
+  def self.empty?(value)
+    return true if value.nil?
+    return true if value.respond_to?(:empty?) && value.empty?
+    return true if value.is_a?(String) && /\A[[:space:]]*\z/ === value
+    false
+  end
+
+  def self.checked?(value)
+    !(['0', 'false', ''].include?(value.to_s.strip))
+  end
+
+  def self.excluding_empties(input)
+    output = input.dup
+    output.each do |key, value|
+      if value.is_a?(Array)
+        output[key] = value.reject { |v| empty?(v) }
+      end
+      if value.is_a?(Hash)
+        output[key] = value.reject { |k, v| empty?(v) }
+      end
+    end
+    output.reject { |key, value| empty?(value) }
+  end
+
+end

data/lib/searchlight/search.rb

@@ -1,117 +1,69 @@
-module Searchlight
-  class Search
-    extend DSL
+require_relative "options"
 
-    def self.search_target
-      return @search_target           if defined?(@search_target)
-      return superclass.search_target if superclass.respond_to?(:search_target) && superclass != Searchlight::Search
-      guess_search_class!
-    end
-
-    def initialize(options = {})
-      filter_and_mass_assign(options)
-    end
-
-    def search
-      @search ||= begin
-                    target = self.class.search_target
-                    if callable?(target)
-                      # for delayed scope evaluation
-                      target.call
-                    else
-                      target
-                    end
-                  end
-    end
-
-    def results
-      @results ||= run
-    end
-
-    def options
-      search_attributes.reduce({}) { |hash, option_name|
-        option_val = send(option_name)
-        hash.tap { |hash| hash[option_name.to_sym] = option_val unless is_blank?(option_val) }
-      }
-    end
+class Searchlight::Search
 
-    protected
+  SEARCH_METHOD_PATTERN = /\Asearch_(?<option>.*)/
 
-    attr_writer :search
-
-    private
-
-    def search_attributes
-      public_methods.map(&:to_s).select { |m| m.start_with?('search_') }.map { |m| m.sub(/\Asearch_/, '') }
-    end
-
-    def self.guess_search_class!
-      if self.name.end_with?('Search')
-        @search_target = name.sub(/Search\z/, '').split('::').inject(Kernel, &:const_get)
-      else
-        raise MissingSearchTarget, "No search target provided via `search_on` and Searchlight can't guess one."
-      end
-    rescue NameError => e
-      raise e unless /uninitialized constant/.match(e.message)
-      raise MissingSearchTarget, "No search target provided via `search_on` and Searchlight's guess was wrong. Error: #{e.message}"
-    end
-
-    def self.search_target=(value)
-      @search_target = value
-    end
+  attr_accessor :query
+  attr_reader   :raw_options
 
-    def filter_and_mass_assign(provided_options = {})
-      options = (provided_options || {}).reject { |key, value| is_blank?(value) }
-      begin
-        options.each { |key, value| public_send("#{key}=", value) } if options && options.any?
-      rescue NoMethodError => e
-        raise UndefinedOption.new(e.name, self)
+  def self.method_added(method_name)
+    method_name.to_s.match(SEARCH_METHOD_PATTERN) do |match|
+      option_name = match.captures.fetch(0)
+      # accessor - eg, if method_name is #search_title, define #title
+      define_method(option_name) do
+        options[option_name]
       end
     end
+  end
 
-    def run
-      options.each do |option_name, value|
-        new_search  = public_send("search_#{option_name}")
-        self.search = new_search unless new_search.nil?
-      end
-      search
-    end
+  def initialize(raw_options = {})
+    @raw_options = raw_options
+  end
 
-    # Note that false is not blank
-    def is_blank?(value)
-      return true if value.respond_to?(:all?) && value.all? { |v| is_blank?(v) }
-      return true if value.respond_to?(:empty?) && value.empty?
-      return true if value.nil? || value.to_s.strip == ''
-      false
-    end
+  def results
+    @results ||= run
+  end
 
-    def callable?(target)
-      # The obvious implementation would be 'respond_to?(:call)`, but
-      # then we may use Sequel::Dataset#call by accident.
-      target.is_a?(Proc)
-    end
+  def options
+    Searchlight::Options.excluding_empties(raw_options)
+  end
 
-    MissingSearchTarget = Class.new(Searchlight::Error)
+  def empty?(value)
+    Searchlight::Options.empty?(value)
+  end
 
-    class UndefinedOption < Searchlight::Error
+  def checked?(value)
+    Searchlight::Options.checked?(value)
+  end
 
-      attr_accessor :message
+  def explain
+    [
+      "Initialized with `raw_options`: #{raw_options.keys.inspect}",
+      "Of those, the non-blank ones are available as `options`: #{options.keys.inspect}",
+      "Of those, the following have corresponding `search_` methods: #{options_with_search_methods.keys}. These would be used to build the query.",
+      "Blank options are: #{(raw_options.keys - options.keys).inspect}",
+      "Non-blank options with no corresponding `search_` method are: #{options.keys - options_with_search_methods.keys}",
+    ].join("\n\n")
+  end
 
-      def initialize(option_name, search)
-        option_name = option_name.to_s.sub(/=\Z/, '')
-        self.message = "#{search.class.name} doesn't search '#{option_name}' or have an accessor for that property."
-        if option_name.start_with?('search_')
-          method_maybe_intended = option_name.sub(/\Asearch_/, '')
-          # Gee golly, I'm so helpful!
-          self.message << " Did you just mean '#{method_maybe_intended}'?" if search.respond_to?("#{method_maybe_intended}=")
-        end
+  def options_with_search_methods
+    {}.tap do |map|
+      options.each do |option_name, option_value|
+        method_name = "search_#{option_name}" 
+        map[option_name] = method_name if respond_to?(method_name)
       end
+    end
+  end
 
-      def to_s
-        message
-      end
+  private
 
+  def run
+    self.query = base_query
+    options_with_search_methods.each do |option, method_name|
+      self.query = public_send(method_name)
     end
-
+    query
   end
+
 end

data/lib/searchlight/version.rb

@@ -1,3 +1,3 @@
 module Searchlight
-  VERSION = "3.1.1"
+  VERSION = "4.0.0"
 end

data/searchlight.gemspec

@@ -19,12 +19,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "named", "~> 1.0"
-
-  spec.add_development_dependency "rspec",     "~> 2.14"
+  spec.add_development_dependency "rspec",     "~> 3.2"
   spec.add_development_dependency "bundler",   "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "capybara",  "~> 2.0"
+  spec.add_development_dependency "capybara",  "~> 2.4"
 
   # To test integration with actionview and activerecord
   spec.add_development_dependency "actionview",         "~> 4.1"

data/spec/searchlight/adapters/action_view_spec.rb

@@ -1,25 +1,28 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe 'Searchlight::Adapters::ActionView', type: :feature, adapter: true do
+describe "Searchlight::Adapters::ActionView", type: :feature do
 
   let(:view)   { ::ActionView::Base.new }
-  let(:search) { AccountSearch.new(paid_amount: 15) }
+  let(:search) { BookSearch.new("title_like" => "Love Among the Chickens") }
 
   before :all do
     # Only required when running these tests
-    require 'searchlight/adapters/action_view'
+    require "searchlight/adapters/action_view"
+    BookSearch.send(:include, Searchlight::Adapters::ActionView)
   end
 
   before :each do
-    view.stub(:protect_against_forgery?).and_return(false)
+    allow(view).to receive(:protect_against_forgery?).and_return(false)
   end
 
   it "it can be used to build a form" do
     form = view.form_for(search, url: '#') do |f|
-      f.text_field(:paid_amount)
+      f.text_field(:title_like)
     end
 
-    expect(form).to have_selector("form input[name='account_search[paid_amount]'][value='15']")
+    expect(form).to have_selector(
+      "form input[name='book_search[title_like]'][value='Love Among the Chickens']"
+    )
   end
 
   it "tells the form that it is not persisted" do

data/spec/searchlight/options_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Searchlight::Options do
+
+  let(:mod) { described_class }
+
+  describe "checked?" do
+
+    {
+      true      => true,
+      "true"    => true,
+      "yeppers" => true,
+      1         => true,
+      "1"       => true,
+      15        => true,
+      false     => false,
+      nil       => false,
+      "false"   => false,
+      0         => false,
+      "0"       => false,
+      ""        => false,
+      " "       => false,
+    }.each do |input, output|
+
+      it "checked?(#{input.inspect}) is #{output.inspect}" do
+        expect(mod.checked?(input)).to eq(output)
+      end
+
+    end
+
+  end
+
+  describe "empty?" do
+    [ nil, "", "   ", "  \n\t  \r ", "　", "\u00a0", [], {} ].each do |blank_val|
+
+      it "empty?(#{blank_val.inspect}) is true" do
+        expect(mod.empty?(blank_val)).to eq(true)
+      end
+
+    end
+
+    [Object.new, true, false, 0, 1, "a", { nil => nil }].each do |present_val|
+
+      it "empty?(#{present_val.inspect}) is false" do
+        expect(mod.empty?(present_val)).to eq(false)
+      end
+
+    end
+
+  end
+
+  describe "excluding empties" do
+
+    it "removes empty values at the top level of the hash" do
+      expect(
+        mod.excluding_empties(
+          name: "Bob",
+          age: nil,
+          likes: ["pizza", "fish"],
+          dislikes: [],
+          elvish: false,
+          relations: {uncle: "Jimmy"},
+          eh: {},
+        )
+      ).to eq(
+        name: "Bob",
+        likes: ["pizza", "fish"],
+        relations: {uncle: "Jimmy"},
+        elvish: false,
+      )
+    end
+
+    # Because I don't expect such structures in form parameters.
+    # If I'm wrong, this can be changed to be recursive.
+    it "does not remove empty values from more deeply-nested elements" do
+      expect(
+        mod.excluding_empties(
+          tags: ["one", "two", "", nil, "three", ["a", "", nil, "b"], {a: ""}]
+        )
+      ).to eq(
+        tags: ["one", "two", "three", ["a", "", nil, "b"], {a: ""}]
+      )
+    end
+
+    it "does not modify the incoming hash" do
+      build_options_hash = proc {
+        {
+          name: "Bob",
+          age: nil,
+          likes: ["pizza", "fish", ""],
+          dislikes: [],
+          elvish: false,
+          relations: {uncle: "Jimmy", foo: nil},
+          eh: {},
+        }
+      }
+      examples = Array.new(2) { build_options_hash.call }
+      mod.excluding_empties(examples[0])
+      expect(examples[0]).to eq(examples[1])
+    end
+
+  end
+
+end

data/spec/searchlight/search_spec.rb

@@ -2,399 +2,60 @@ require 'spec_helper'
 
 describe Searchlight::Search do
 
-  let(:search_class)     { Named::Class.new('ExampleSearch', described_class).tap {|klass|
-    klass.searches *allowed_options
-    allowed_options.each { |name| klass.send(:define_method, "search_#{name}") {} }
+  let(:raw_options) {
+    {
+      title_like: "Mere Christianity",
+      "author_name_like" => "Lew",
+      category_in: nil,
+      tags: ["", "fancy"],
+      book_thickness: "smallish",
+      parts_about_lolcats: "",
     }
   }
-  let(:allowed_options)  { Hash.new }
-  let(:provided_options) { Hash.new }
-  let(:search)           { search_class.new(provided_options) }
+  let(:search) { BookSearch.new(raw_options) }
 
-  describe "options" do
-
-    context "when given valid options" do
-
-      context "when the search class has no defaults" do
-
-        describe "screening options" do
-
-          let(:allowed_options) { [:name, :description, :categories, :nicknames] }
-
-          context "when all options are usable" do
-
-            let(:provided_options) { {name: 'Roy', description: 'Ornry', categories: %w[mammal moonshiner], nicknames: %w[Slim Bubba]} }
-
-            it "adds them to the options accessor" do
-              expect(search.options).to eq(provided_options)
-            end
-
-          end
-
-          context "when some provided options are empty" do
-
-            let(:provided_options) { {name: 'Roy', description: '', categories: ['', ''], nicknames: []} }
-
-            it "does not add them to the options accessor" do
-              expect(search.options).to eq(name: 'Roy')
-            end
-
-          end
-
-          context "when an empty options hash is given" do
-
-            let(:provided_options) { {} }
-
-            it "has empty options" do
-              expect(search.options).to eq({})
-            end
-
-          end
-
-          context "when the options are explicitly nil" do
-
-            let(:provided_options) { nil }
-
-            it "has empty options" do
-              expect(search.options).to eq({})
-            end
-
-          end
-
-          context "when some options are do not map to search methods (eg, attr_accessor)" do
-            let(:search_class) {
-              Named::Class.new('ExampleSearch', described_class) do
-                attr_accessor :krazy_mode
-                def search_name; end
-              end.tap { |klass| klass.searches *allowed_options }
-            }
-            let(:provided_options) { {name: 'Reese Roper', krazy_mode: true} }
-
-            it "sets all the provided values" do
-              expect(search.name).to       eq('Reese Roper')
-              expect(search.krazy_mode).to eq(true)
-            end
-
-            it "only lists options for the values corresponding to search methods" do
-              expect(search.options).to eq({name: 'Reese Roper'})
-            end
-
-          end
-
-        end
-
-      end
-
-      context "when the search class has defaults" do
-
-        let(:allowed_options) { [:name, :age] }
-        let(:search_class) {
-          Named::Class.new('ExampleSearch', described_class) do
-
-            def initialize(options)
-              super
-              self.name ||= 'Dennis'
-              self.age  ||= 37
-            end
-
-            def search_name; end
-            def search_age;  end
-
-          end.tap { |klass| klass.searches *allowed_options }
-        }
-
-        context "and there were no values given" do
-
-          let(:provided_options) { Hash.new }
-
-          it "uses the defaults for its accessors" do
-            expect(search.name).to eq('Dennis')
-            expect(search.age).to eq(37)
-          end
-
-          it "uses the defaults for its options hash" do
-            expect(search.options).to eq({name: 'Dennis', age: 37})
-          end
-
-        end
-
-        context "and values are given" do
-
-          let(:provided_options) { {name: 'Treebeard', age: 'A few thousand'} }
-
-          it "uses the provided values" do
-            expect(search.name).to eq('Treebeard')
-            expect(search.age).to eq('A few thousand')
-          end
-
-          it "uses the provided values for its options hash" do
-            expect(search.options).to eq({name: 'Treebeard', age: 'A few thousand'})
-          end
-
-        end
-
-      end
+  describe "parsing options" do
 
+    it "makes the raw options available" do
+      expect(search.raw_options).to equal(raw_options)
     end
 
-    context "when given invalid options" do
-
-      let(:provided_options) { {genus: 'Mellivora'} }
-
-      it "raises an error explaining that this search class doesn't search the given property" do
-        expect { search }.to raise_error( Searchlight::Search::UndefinedOption, /ExampleSearch.*genus/)
-      end
-
-      it "gives the error a readable string representation" do
-        error   = Searchlight::Search::UndefinedOption.new(:badger_height, Array)
-        expect(error.to_s).to eq(error.message)
-      end
-
-      context "if the provided option starts with 'search_'" do
-
-        let(:allowed_options)  { [:genus] }
-
-        context "and it looks like a valid search option" do
-
-          let(:provided_options) { {search_genus: 'Mellivora'} }
-
-          it "suggests the option name the user may have meant to provide" do
-            expect { search }.to raise_error( Searchlight::Search::UndefinedOption, /ExampleSearch.*genus.*Did you just mean/)
-          end
-
-        end
-
-        context "but doesn't look like a valid search option" do
-
-          let(:provided_options) { {search_girth: 'Wee'} }
-
-          it "doesn't suggest an option name" do
-            begin
-              search
-            rescue Searchlight::Search::UndefinedOption => exception
-              expect(exception.message.match(/Did you just mean/)).to be_nil
-            end
-          end
-
-        end
-
-      end
-
+    it "returns only useful values as `options`" do
+      expect(search.options).to eq(
+        title_like: "Mere Christianity",
+        "author_name_like" => "Lew",
+        book_thickness: "smallish",
+        in_print: "either",
+        tags: ["fancy"],
+      )
     end
 
-  end
-
-  describe "search_on" do
-
-    context "when an explicit search target was provided and it's not a proc" do
-
-      let(:example_search_target) { "Bobby Fischer" }
-
-      before :each do
-        search_class.search_on example_search_target
-      end
-
-      it "makes the object accessible via `search_target`" do
-        expect(search_class.search_target).to eq(example_search_target)
-      end
-
-      it "makes the search target available to its children" do
-        expect(SpiffyAccountSearch.search_target).to be(MockModel)
-      end
-
-      it "allows the children to set their own search target" do
-        klass = Class.new(SpiffyAccountSearch) { search_on Array }
-        expect(klass.search_target).to be(Array)
-        expect(SpiffyAccountSearch.search_target).to be(MockModel)
-      end
-
-    end
-
-    context "when an explicit search target was provided and it is a proc" do
-
-      it "calls it in the process of producing search results" do
-        search = ProcSearch.new(first_name: "Jimmy")
-        results = search.results
-        expect(results).to be_a(MockRelation)
-        expect(results.called_methods).to eq([:some_scope, :where])
-      end
-
-      it "allows it to refer to a parent class's callable search target" do
-        search = ChildProcSearch.new(first_name: "Carlos")
-        results = search.results
-        expect(results).to be_a(MockRelation)
-        expect(results.called_methods).to eq([:some_scope, :other_scope, :where])
-      end
-
-    end
-
-    context "when no explicit search target was provided" do
-
-      let(:search_class) { Named::Class.new('Namespaced::ExampleSearch', described_class) }
-
-      it "guesses the search class based on its own namespaced class name" do
-        expect(search_class.search_target).to eq(Namespaced::Example)
-      end
-
-      context "when it can't make a guess as to the search class" do
-
-        let(:search_class) { Named::Class.new('Somekinda::Searchthingy', described_class) }
-
-        it "raises an exception" do
-          expect{search_class.search_target}.to raise_error(
-            Searchlight::Search::MissingSearchTarget, 
-            /No search target/
-          )
-        end
-
-      end
-
-      context "when it tries to guess the search class but fails" do
-        
-        let(:search_class) { Named::Class.new('NonExistentObjectSearch', described_class) }
-
-        it "raises an exception" do
-          expect{search_class.search_target}.to raise_error(
-            Searchlight::Search::MissingSearchTarget, 
-            /No search target.*uninitialized constant.*NonExistentObject/
-          )
-        end
-
-      end
-
-    end
-
-  end
-
-  describe "individual option accessors" do
-
-    describe "the accessors module" do
-
-      before :each do
-        search_class.searches :foo
-        search_class.searches :bar
-        search_class.searches :stuff
-      end
-
-      it "includes exactly one SearchlightAccessors module for this class" do
-        accessors_modules = search_class.ancestors.select {|a| a.name =~ /\ASearchlightAccessors/ }
-        expect(accessors_modules.length).to eq(1)
-        expect(accessors_modules.first).to be_a(Named::Module)
-      end
-    end
-
-    describe "value accessors" do
-
-      let(:allowed_options)  { [:beak_color] }
-      let(:provided_options) { {beak_color: 'mauve'} }
-
-      it "provides an getter for the value" do
-        search_class.searches :beak_color
-        expect(search.beak_color).to eq('mauve')
-      end
-
-      it "provides an setter for the value" do
-        search_class.searches :beak_color
-        search.beak_color = 'turquoise'
-        expect(search.beak_color).to eq('turquoise')
-      end
-
-    end
-
-    describe "boolean accessors" do
-
-      let(:provided_options) { {has_beak: has_beak} }
-
-      before :each do
-        search_class.searches :has_beak
-      end
-
-      {
-        'yeppers' => true,
-        1         => true,
-        '1'       => true,
-        15        => true,
-        'true'    => true,
-        0         => false,
-        '0'       => false,
-        ''        => false,
-        ' '       => false,
-        nil       => false,
-        'false'   => false
-      }.each do |input, output|
-
-        describe input.inspect do
-
-          let(:has_beak) { input }
-
-          it "becomes boolean #{output}" do
-            expect(search.has_beak?).to eq(output)
-          end
-
-        end
-
-      end
-
+    it "knows which of the `options` have matching search_ methods" do
+      expect(search.options_with_search_methods).to eq(
+        title_like: "search_title_like",
+        "author_name_like" => "search_author_name_like",
+        in_print: "search_in_print",
+      )
     end
-
   end
 
-  describe "search" do
+  describe "querying" do
 
-    let(:search) { AccountSearch.new }
-
-    it "is initialized with the search_target" do
-      expect(search.search).to eq(MockModel)
-    end
-
-  end
-
-  describe "results" do
-
-    let(:search) { AccountSearch.new(paid_amount: 50, business_name: "Rod's Meat Shack", other_attribute: 'whatevs') }
-
-    it "builds a search by calling each search method that corresponds to a provided option" do
-      search.should_receive(:search_paid_amount).and_call_original
-      search.should_receive(:search_business_name).and_call_original
-      # Can't do `.should_not_receive(:search_other_attribute)` because the expectation defines a method which would get called.
-      search.results
-      expect(search.search.called_methods).to eq(2.times.map { :where })
-    end
-
-    it "returns the search" do
-      expect(search.results).to eq(search.search)
+    it "builds results by running all methods matching its options" do
+      expect(search).to receive(:search_title_like).and_call_original
+      expect(search).to receive(:search_author_name_like).and_call_original
+      expect(search.results.called_methods).to eq([:all, :order, :merge, :joins, :merge])
     end
 
     it "only runs the search once" do
-      search.should_receive(:run).once.and_call_original
+      expect(search).to receive(:run).once.and_call_original
       2.times { search.results }
     end
 
   end
 
-  describe "run" do
-
-    let(:search_class) {
-      Named::Class.new('TinyBs', described_class) do
-        search_on Object
-        searches :bits, :bats, :bots
-
-        def search_bits; end
-        def search_bats; end
-        def search_bots; end
-
-      end
-    }
-
-    let(:provided_options) { {bits: ' ', bats: nil, bots: false} }
-
-    it "only runs search methods that have real values to search on" do
-      search.should_not_receive(:search_bits)
-      search.should_not_receive(:search_bats)
-      search.should_receive(:search_bots)
-      search.send(:run)
-    end
-
+  it "has an 'explain' method to show how it builds its query" do
+    expect(search.explain).to be_a(String)
   end
 
 end