searchlight 0.0.1 → 0.9.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTA2YmIzYjk0NDhkNjdlNTg5MWU3MWQzOWExOTg0Mzg0Y2VmYjhkYw==
+    NGRhMjI1Mjg1ZDRmYTA5Yjc1YTk1ZWVkZWY5M2VhNjQ2YmQ0YzRhYQ==
   data.tar.gz: !binary |-
-    N2I3MmFlOGEzMjFiODcyNjUxNzA1ZWUxZjg4YmY5OTk0OWZjZGNlOQ==
+    NTU2MjMxYTdmY2YwNTYxZDY4YzU0NTY2ZjczNGRjMjlmNTM3MWFiZg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OWUxMjY2OGYxMjNmZGJiOTgyYjY3OGVkYzgxOWI4NTQ2ZmI2YzA2N2MwYTA4
-    NGQ3Y2FjYmM4MTRjZGU2OWY1YjQ3MDg3MmJjNDAxMzY1NWM2OTJjN2VlZDNh
-    MzY5YjIzZjE2MGRkYzVmZTMyMTI3ZmU3MzVkMTU0MTliZjVmNzI=
+    OWE1NWE0ZDc3N2MyMGJiNzZmY2MwNGYzMzg4NWVmNjY4MWQyYzY5ZGEzZmQz
+    YjIwYmE4ZGJkZDhkNzhkNmM0MDNhODBiMzRhMTVjODY1MjM2NjJkMzhkNzZi
+    ODVmZDMyMGQ2N2Q1YWEwMDVlOTI0Zjg5YjBmYjYzZjZjOTU2M2U=
   data.tar.gz: !binary |-
-    ODJjNGM2NmQzNWFjY2FlYjUwN2EzNGQwN2MzNjI2Njg4MjE2NWUxNzg3ZjJl
-    ZDk4NzcxYzUzNzE4NWQ3ODg5NGZmZmUwOGM0ODljOTE5MDRiYWIzMmMzMDJl
-    MTMzMWU2YmEwMWY3MjM2MzU1MjJlZTk0MDNlNjBmY2VjM2U5ZGQ=
+    YmNhN2M0M2VjMmM0MTZmMjBmOTI1ODJlMzE0NWI0YTVhZDA2ZDIzYWY0NTYx
+    YjFhM2QxMGZmZGY3MTFkNzg0NWY0YmMzN2MxMTViMjlmMWQyMTRiYjEzZTAy
+    MjMyZTY5YjRjYWM1NjI2ZTE0MjNmN2UyMWM2MDVmNzliMmMyMDU=

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode # JRuby in 1.9 mode
+  - 2.0.0

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+Searchlight does its best to use [semantic versioning](http://semver.org).
+
+## v0.0.1
+
+Experimental and unstable, Searchlight totters onto the scene and takes its first wide-eyed look at the world.
+
+It is adorable.

data/README.md

@@ -2,98 +2,253 @@
 
 Searchlight helps you build searches from options via Ruby methods that you write.
 
-Searchlight comes with ActiveRecord integration, but can call search methods on any ORM or object that allows chaining search methods.
+Searchlight can work with any ORM or object that allows chaining search methods. It comes with modules for integrating with ActiveRecord and ActionView, but can easily be used in any Ruby program.
 
 [![Build Status](https://api.travis-ci.org/nathanl/searchlight.png?branch=master)](https://travis-ci.org/nathanl/searchlight)
 [![Code Climate](https://codeclimate.com/github/nathanl/searchlight.png)](https://codeclimate.com/github/nathanl/searchlight)
 
 ## Overview
 
-The basic idea of Searchlight is to build a search by chaining method calls that you define. It calls methods on the object you specify, based on the options you pass.
+The basic idea of Searchlight is to build a search by chaining method calls that you define. It calls **public** methods on the object you specify, based on the options you pass.
 
-For example, if you have a Searchlight search class called `FooSearch`, and you instantiate it like this:
+For example, if you have a Searchlight search class called `YetiSearch`, and you instantiate it like this:
 
 ```ruby
-  foo_search = FooSearch(active: true, name: 'Jimmy', location_in: %w[NY LA]) # or params[:query]
+  yeti_search = YetiSearch(active: true, name: 'Jimmy', location_in: %w[NY LA]) # or params[:search]
 ```
 
-... calling `results` will call the instance methods `search_active`, `search_name`, and `search_location_in`. (If you omit the `active` option, `search_active` won't be called.)
+... calling `results` on the instance will build a search by chaining calls to `search_active`, `search_name`, and `search_location`.
 
-The `results` method will then return the return value of the last search method. If you're using ActiveRecord, this would be an `ActiveRecord::Relation`. You can then call `each` to loop through the results, `to_sql` to get the generated query, etc.
+The `results` method will then return the return value of the last search method. If you're using ActiveRecord, this would be an `ActiveRecord::Relation`, and you can then call `each` to loop through the results, `to_sql` to get the generated query, etc.
 
 ## Usage
 
 ### Search class
 
-Here's an example search class that uses ActiveRecord.
+A search class has three main parts: a target, options, and methods. For example:
 
 ```ruby
-# app/searches/account_search.rb
-class AccountSearch < Searchlight::Search
+class PersonSearch < Searchlight::Search
 
-  # Defines the `search_target`
-  search_on Account
+  # The search target; in this case, an ActiveRecord model.
+  search_on Person
 
-  # The search options this class knows how to handle
-  searches :contract_id, :invoicing_status, :active
+  # The options the search understands. Supply any combination of them to an instance.
+  searches :first_name, :last_name
 
-  # If a `contract_id` option is given, this method will be called
-  def search_contract_id
-    search.where(contract_id: contract_id)
+  # A search method.
+  def search_first_name
+    # If this is the first search method called, `search` here will be
+    # the search target, namely, `Person`.
+    # `first_name` is an automatically-defined accessor for the option value.
+    search.where(first_name: first_name)
   end
 
-  # If an `invoicing` option is given, this method will be called
-  def search_invoicing
-    case invoicing_status
-    when 'partial'
-      search.partially_invoiced
-    when 'complete'
-      search.completely_invoiced
-    when 'never'
-      search.uninvoiced
-    else
-      search
-    end
+  # Another search method.
+  def search_last_name
+    # If this is the second search method called, `search` here will be
+    # whatever `search_first_name` returned.
+    search.where(last_name: last_name)
+  end
+end
+```
+
+Here's a fuller example search class.
+
+```ruby
+# app/searches/city_search.rb
+class CitySearch < Searchlight::Search
+
+  # `City` here is an ActiveRecord model (see notes below on the adapter)
+  search_on City.includes(:country)
+
+  searches :name, :continent, :country_name_like, :is_megacity
+
+  # Reach into other tables
+  def search_continent
+    search.where('`countries`.`continent` = ?', continent)
+  end
+
+  # Other kinds of queries
+  def search_country_name_like
+    search.where("`countries`.`name` LIKE ?", "%#{country_name_like}%")
   end
 
-  # If an `active` option is given, this method will be called
-  def search_active
-    search.where(status: active? ? 'active' : 'inactive')
+  # For every option, we also add an accessor that coerces to a boolean,
+  # considering 'false', 0, and '0' to be false
+  def search_is_megacity
+    search.where("`cities`.`population` #{is_megacity? ? '>=' : '<'} ?", 10_000_000)
   end
 
 end
 ```
 
-### Controller
+Here are some example searches.
 
 ```ruby
-# app/controllers/accounts_controller.rb
-class AccountsController
+CitySearch.new.results.to_sql
+  # => "SELECT `cities`.* FROM `cities` "
+CitySearch.new(name: 'Nairobi').results.to_sql
+  # => "SELECT `cities`.* FROM `cities`  WHERE `cities`.`name` = 'Nairobi'"
+
+CitySearch.new(country_name_like: 'aust', continent: 'Europe').results.count # => 6
+
+non_megas = CitySearch.new(is_megacity: 'false')
+non_megas.results.to_sql 
+  # => "SELECT `cities`.* FROM `cities`  WHERE (`cities`.`population` < 100000"
+non_megas.results.each do |city|
+  # ...
+end
+```
+
+### Accessors
+
+For each search option, Searchlight defines two accessors: one for a value, and one for a boolean.
+
+For example, if your class `searches :awesomeness` and gets instantiated like:
+
+```ruby
+search = MySearchClass(awesomeness: 'Xtreme')
+```
+
+... your search methods can use:
+
+- `awesomeness` to retrive the given value, `'Xtreme'`
+- `awesomeness?` to get a boolean version: `true`
+
+The boolean conversion is form-friendly, so that `0`, `'0'`, and `'false'` are considered `false`.
+
+All accessors are defined in modules, so you can override them and use `super` to call the original methods.
+
+```ruby
+class PersonSearch < Searchlight::Search
+
+  searches :names, :awesomeness
+
+  def names
+    # Make sure this is an array and never search for Jimmy.
+    # Jimmy is a private man. An old-fashioned man. Leave him be.
+    Array(super).reject { |name| name == 'Jimmy' }
+  end
+
+  def searches_names
+    search.where("name IN (?)", names)
+  end
+
+  def awesomeness?
+    # Disagree about what is awesome
+    !super
+  end
 
-def search
-  @search = AccountSearch.new(params[:search])
 end
-...
 ```
 
-### View
+### Defining Defaults
+
+```ruby
+
+class CitySearch < Searchlight::Search
+
+  #...
+
+  def initialize(options = {})
+    super
+    self.continent ||= 'Asia'
+  end
+
+  #...
+end
+
+CitySearch.new.results.to_sql
+  => "SELECT `cities`.* FROM `cities`  WHERE (`countries`.`continent` = 'Asia')"
+CitySearch.new(continent: 'Europe').results.to_sql
+  => "SELECT `cities`.* FROM `cities`  WHERE (`countries`.`continent` = 'Europe')"
+```
+
+### Subclassing
+
+You can subclass an existing search class and support all the same options with a different search target. This may be useful for single table inheritance, for example. 
+
 ```ruby
-# app/views/accounts/index.html.haml
+class VillageSearch < CitySearch
+  search_on Village
+end
+```
+
+You can also use `search_target` to get the superclass's `search_on` value, so you can do this:
+
+```ruby
+class SmallTownSearch < CitySearch
+  search_on search_target.where("`cities`.`population` < ?", 1_000)
+end
+
+SmallTownSearch.new(country_name_like: 'Norfolk').results.to_sql
+  => "SELECT `cities`.* FROM `cities`  WHERE (`cities`.`population` < 1000) AND (`countries`.`name` LIKE '%Norfolk%')"
+```
+
+## Usage in Rails
+
+Searchlight plays nicely with Rails views.
+
+```ruby
+# app/views/cities/index.html.haml
 ...
-= form_for(search, url: '#') do |f|
+= form_for(@search, url: search_cities_path) do |f|
+  %fieldset
+    = f.label      :name, "Name"
+    = f.text_field :name
+
   %fieldset
-    = f.label  :contract_id, "Contract"
-    = f.select :contract_id, available_contracts_collection
+    = f.label      :country_name_like, "Country Name Like"
+    = f.text_field :country_name_like
 
   %fieldset
-    = f.label  :invoicing_status, "Invoicing Status"
-    = f.select :invoicing_status, invoice_statuses_collection
+    = f.label  :is_megacity, "Megacity?"
+    = f.select :is_megacity, [['Yes', true], ['No', false], ['Either', '']]
 
   %fieldset
-    = f.label  :active, "Active?"
-    = f.select :active, [['Active', true], ['Inactive', false], ['Either', nil]]
+    = f.label  :continent, "Continent"
+    = f.select :continent, ['Africa', 'Asia', 'Europe'], include_blank: true
+
+  = f.submit "Search"
 ```
 
+As long as your form submits options your search understands, you can easily hook it up in your controller:
+
+```ruby
+# app/controllers/cities_controller.rb
+class CitiesController < ApplicationController
+  def search
+    @search = CitySearch.new(params[:search])
+  end
+end
+```
+## Adapters
+
+Currently, Searchlight has adapters for ActiveRecord and ActionView. We'd love to get pull requests for others. :)
+
+### ActiveRecord
+
+When you call `search_on` in your Searchlight class, Searchlight checks whether the search target comes from ActiveRecord, and, if so, mixes a module into your class.
+
+For each of your search options, the module will have the simplest possible search method defined. For example, if your class `searches :name`, the module will have this method:
+
+```ruby
+  def search_name
+    search.where(name: name)
+  end
+```
+
+Since that method is in a parent module, you can easily override it by defining your own method. You can also call `super` in the method you define.
+
+### ActionView
+
+Similarly, Searchlight adds ActionView-friendly methods to your classes if it sees that `ActionView` is a defined constant. See the code for details, but the upshot is that you can use a search with `form_for`.
+
+## Compatibility
+
+For any given version, check `.travis.yml` to see what Ruby versions we're testing for compatibility.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -115,3 +270,8 @@ Or install it yourself as:
 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
+
+## Shout Outs
+
+- The excellent [Mr. Adam Hunter](https://github.com/adamhunter), co-creator of Searchlight.
+- [TMA](http://tma1.com) for supporting the development of Searchlight.

data/TODO.md

@@ -0,0 +1,5 @@
+# TODO
+
+- Run rcov and mutant
+- Make nice Github page
+- Test with ActiveRecord 4

data/lib/searchlight/adapters/action_view.rb

@@ -5,7 +5,7 @@ module Searchlight
       module ClassMethods
 
         def model_name
-          ActiveModel::Name.new(self, nil, 'query')
+          ActiveModel::Name.new(self, nil, 'search')
         end
 
       end
@@ -16,6 +16,10 @@ module Searchlight
           []
         end
 
+        def persisted?
+          false
+        end
+
       end
 
     end

data/lib/searchlight/adapters/active_record.rb

@@ -4,22 +4,28 @@ module Searchlight
 
       def search_on(target)
         super
-        extend Search if target.is_a?(::ActiveRecord::Base)
+        extend Search if target.is_a?(::ActiveRecord::Base) || target.is_a?(::ActiveRecord::Relation)
       end
 
       module Search
         def searches(*attribute_names)
           super
 
-          include_new_module "SearchlightActiveRecordSearches" do
-            attribute_names.each do |attribute_name|
-              define_method("search_#{attribute_name}") do
-                search.where(attribute_name => public_send(attribute_name))
-              end
-            end
+          # Ensure this class only adds one search module to the ancestors chain
+          if @ar_searches_module.nil?
+            @ar_searches_module = Named::Module.new("SearchlightActiveRecordSearches(#{self})")
+            include @ar_searches_module
           end
 
-          attribute_names.each { |attribute_name| method_added("search_#{attribute_name}") }
+          eval_string = attribute_names.map { |attribute_name|
+            <<-UNICORN_BILE
+            def search_#{attribute_name}
+              search.where('#{attribute_name}' => public_send("#{attribute_name}"))
+            end
+            UNICORN_BILE
+          }.join
+
+          @ar_searches_module.module_eval(eval_string, __FILE__, __LINE__)
         end
       end
 

data/lib/searchlight/dsl.rb

@@ -6,25 +6,28 @@ module Searchlight
     end
 
     def searches(*attribute_names)
-      include_new_module "SearchlightAccessors" do
-        attr_accessor *attribute_names
 
-        # define boolean accessors
-        attribute_names.each do |attribute_name|
-          define_method("#{attribute_name}?") do
-            # Treat 0 (eg, from checkboxes) as false
-            !['0', 'false', ''].include?(public_send(attribute_name).to_s.strip) 
+      # Ensure this class only adds one accessors module to the ancestors chain
+      if @accessors_module.nil?
+        @accessors_module = Named::Module.new("SearchlightAccessors(#{self})") do
+          private
+          # Treat 0 (eg, from checkboxes) as false
+          def truthy?(value)
+            !(['0', 'false', ''].include?(value.to_s.strip))
           end
         end
+        include @accessors_module
       end
-    end
-
-    private
 
-    # So that we can allow calling `super` in submodules and the base class.
-    def include_new_module(module_name, &content)
-      include Named::Module.new(module_name, &content)
+      eval_string = "attr_accessor *#{attribute_names}\n"
+      eval_string << attribute_names.map { |attribute_name|
+        <<-LEPRECHAUN_JUICE
+          def #{attribute_name}?
+            truthy?(public_send("#{attribute_name}"))
+          end
+        LEPRECHAUN_JUICE
+      }.join
+      @accessors_module.module_eval(eval_string, __FILE__, __LINE__)
     end
-
   end
 end

data/lib/searchlight/search.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 module Searchlight
   class Search
     extend DSL
@@ -8,17 +6,10 @@ module Searchlight
       defined?(@search_target) ? @search_target : superclass.search_target
     end
 
-    def self.search_methods
-      defined?(@search_methods) ? @search_methods : superclass.search_methods
-    end
-
-    def self.method_added(name)
-      @search_methods ||= Set.new
-      search_methods << name.to_s if name.to_s.start_with?('search_')
-    end
-
     def initialize(options = {})
-      options.each { |key, value| public_send("#{key}=", value) }
+      options.each { |key, value| public_send("#{key}=", value) } if options && options.any?
+    rescue NoMethodError => e
+      raise UndefinedOption.new(e.name, self.class.name)
     end
 
     def search
@@ -35,15 +26,44 @@ module Searchlight
 
     private
 
+    def search_methods
+      public_methods.map(&:to_s).select { |m| m.start_with?('search_') }
+    end
+
     def run
-      self.class.search_methods.each do |method|
-        option_value = public_send(method.sub(/\Asearch_/, ''))
-        unless option_value.nil? || option_value.to_s.strip == ''
-          self.search  = public_send(method)
-        end
+      search_methods.each do |method|
+        new_search  = run_search_method(method)
+        self.search = new_search unless new_search.nil?
       end
       search
     end
 
+    def run_search_method(method_name)
+      option_value = instance_variable_get("@#{method_name.sub(/\Asearch_/, '')}")
+      option_value = option_value.reject { |item| blank_value?(item) } if option_value.respond_to?(:reject)
+      public_send(method_name) unless blank_value?(option_value)
+    end
+
+    # Note that false is not blank
+    def blank_value?(value)
+      (value.respond_to?(:empty?) && value.empty?) || value.nil? || value.to_s.strip == ''
+    end
+
+    class UndefinedOption < StandardError
+      attr_accessor :message
+      def initialize(option_name, search_class)
+        option_name = option_name.to_s.sub(/=\Z/, '')
+        self.message = "#{search_class} doesn't search '#{option_name}'."
+        if option_name.start_with?('search_')
+          # Gee golly, I'm so helpful!
+          self.message << " Did you just mean '#{option_name.sub(/\Asearch_/, '')}'?"
+        end
+      end
+
+      def to_s
+        message
+      end
+    end
+
   end
 end

data/lib/searchlight/version.rb

@@ -1,3 +1,3 @@
 module Searchlight
-  VERSION = "0.0.1"
+  VERSION = "0.9.0"
 end

data/lib/searchlight.rb

@@ -2,6 +2,7 @@ require 'named'
 require 'searchlight/version'
 
 module Searchlight
+  Error = Class.new(StandardError)
 end
 
 require 'searchlight/dsl'

data/searchlight.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Searchlight::VERSION
   spec.authors       = ["Nathan Long", "Adam Hunter"]
   spec.email         = ["nathanmlong@gmail.com", "adamhunter@me.com"]
-  spec.description   = %q{Searchlight helps you build searches from options via Ruby methods that you write.}
+  spec.description   = %q{Searchlight helps you build searches from options via Ruby methods that you write. Searchlight can work with any ORM or object that allows chaining search methods. It comes with modules for integrating with ActiveRecord and ActionView, but can easily be used in any Ruby program.}
   spec.summary       = %q{Searchlight helps you build searches from options via Ruby methods that you write.}
   spec.homepage      = "https://github.com/nathanl/searchlight"
   spec.license       = "MIT"
@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rails",     ">= 3"
   spec.add_development_dependency "capybara",  "~> 2.0"
+  spec.add_development_dependency "simplecov", "~> 0.7"
 end

data/spec/searchlight/adapters/action_view_spec.rb

@@ -19,7 +19,11 @@ describe 'Searchlight::Adapters::ActionView', type: :feature, adapter: true do
       f.text_field(:paid_amount)
     end
 
-    expect(form).to have_selector("form input[name='query[paid_amount]'][value='15']")
+    expect(form).to have_selector("form input[name='search[paid_amount]'][value='15']")
+  end
+
+  it "tells the form that it is not persisted" do
+    expect(search).not_to be_persisted
   end
 
 end

data/spec/searchlight/adapters/active_record_spec.rb

@@ -19,7 +19,7 @@ describe 'Searchlight::Adapters::ActiveRecord', adapter: true do
   end
 
   it "adds search_elephants to the search_methods array" do
-    expect(search_class.search_methods).to include('search_elephants')
+    expect(search_instance.send(:search_methods)).to include('search_elephants')
   end
 
   it "defines search methods that call where on the search target" do
@@ -27,4 +27,9 @@ describe 'Searchlight::Adapters::ActiveRecord', adapter: true do
     expect(search_instance.search.called_methods).to eq([:where])
   end
 
+  it "sets arguments properly in the defined method" do
+    search_instance.search.should_receive(:where).with('elephants' => 'yes, please')
+    search_instance.search_elephants
+  end
+
 end

data/spec/searchlight/search_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Searchlight::Search do
 
-  let(:search_class) { Named::Class.new('SearchClass', described_class) }
+  let(:search_class) { Named::Class.new('ExampleSearch', described_class) }
   let(:options) { Hash.new }
   let(:search) { search_class.new(options) }
 
@@ -15,6 +15,16 @@ describe Searchlight::Search do
       expect(search.beak_color).to eq('mauve')
     end
 
+    describe "handling invalid options" do
+
+      let(: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
+
+    end
+
   end
 
   describe "search_on" do
@@ -44,7 +54,7 @@ describe Searchlight::Search do
   describe "search_methods" do
 
     let(:search_class) {
-      Named::Class.new('SearchClass', described_class) do
+      Named::Class.new('ExampleSearch', described_class) do
         def search_bees
         end
 
@@ -57,7 +67,7 @@ describe Searchlight::Search do
     }
 
     it "keeps a unique list of the search methods" do
-      expect(search_class.search_methods).to eq(Set.new(['search_bees', 'search_bats']))
+      expect(search.send(:search_methods).map(&:to_s).sort).to eq(['search_bats', 'search_bees'])
     end
 
   end
@@ -68,11 +78,14 @@ describe Searchlight::Search do
 
       before :each do
         search_class.searches :foo
+        search_class.searches :bar
+        search_class.searches :stuff
       end
 
-      it "includes a SearchlightAccessors module" do
-        accessors_module = search_class.ancestors.detect {|a| a.name == 'SearchlightAccessors' }
-        expect(accessors_module).to be_a(Named::Module)
+      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
 
       it "adds a getter" do

data/spec/spec_helper.rb

@@ -1,4 +1,6 @@
 require 'capybara/rspec'
+require 'simplecov'
+SimpleCov.start
 require 'searchlight'
 $LOAD_PATH << '.'
 require 'support/mock_model'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: searchlight
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Nathan Long
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-08 00:00:00.000000000 Z
+date: 2013-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: named
@@ -95,8 +95,24 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
 description: Searchlight helps you build searches from options via Ruby methods that
-  you write.
+  you write. Searchlight can work with any ORM or object that allows chaining search
+  methods. It comes with modules for integrating with ActiveRecord and ActionView,
+  but can easily be used in any Ruby program.
 email:
 - nathanmlong@gmail.com
 - adamhunter@me.com
@@ -106,10 +122,13 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO.md
 - lib/searchlight.rb
 - lib/searchlight/adapters/action_view.rb
 - lib/searchlight/adapters/active_record.rb