meta_search_hub 1.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 821034765c75b62d54b080df44649b5a77a217c6bafd2e5340d8916b9f28ab90
+  data.tar.gz: 5fe057116b6ee5822044ee81564ea3149613a5ab86118c6c602816eb67abe18c
+SHA512:
+  metadata.gz: 605de62eb9f30f3a8050529fd23ddc587f128a36b1ca74c4f6f410ba1a413eb8043e025bc86c37df9715b738f6387e323690c7008feebb7cc7d07079727960cd
+  data.tar.gz: d6d66fd012cd79c0fae03d768d5def43d18a7f7f0b885dbbb202561b8664bbecbbdf505ef4ac0d439fea04ad80fab5b106cb1d034406dfdf335592fff4e638f1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "vendor/arel"]
+	path = vendor/arel
+	url = git://github.com/rails/arel.git
+[submodule "vendor/rails"]
+	path = vendor/rails
+	url = git://github.com/rails/rails.git

data/CHANGELOG

@@ -0,0 +1,109 @@
+Changes since 1.0.4 (2011-04-08):
+  * Add :join_type option to Builder to allow for using InnerJoin if desired
+    (Stephen Pike)
+  * Fix a memory leak in development mode (Bonias)
+
+Changes since 1.0.3 (2011-03-14):
+  * Be sure not to override form_for options if super returns a non-true value,
+    fixes a compatibility issue when using client_side_validation
+
+Changes since 1.0.1 (2011-01-18):
+  * Include all non-boolean types in is_present and is_blank, to match
+    documentation
+  * Avoid setting alias to collection_check_boxes and check_boxes against
+    the base. Fixes issues with SimpleForm compatibility.
+  * Delegate page method to relation, for Kaminari support.
+  * Don't check for existence of attributes if the table doesn't exist yet.
+
+Changes since 1.0.0 (2011-01-17):
+  * Update polymorphic join support to play nicely with MetaWhere
+
+Changes since 0.9.11 (2011-01-06):
+  * Doc updates only.
+
+Changes since 0.9.10 (2010-11-18):
+  * Skip attempts to sort if someone passes an empty string to meta_sort
+  * Allow conditions on search_methods, (attr|assoc)_(un)?searchable using :if.
+    Option should be an object that responds to call and accepts the
+    MetaSearch::Builder instance as a parameter. Unused options passed to the
+    Model.search method will be available for your conditions to act on.
+  * Access attribute setters if a param is supplied - @search.attr_name(val)
+    behaves like @search.attr_name = val
+
+Changes since 0.9.9 (2010-11-15):
+  * Fix bug introduced by new polymorphic belongs_to association code in
+    honoring :url param to form_for
+  * Support localization of predicate text in labels
+  * Fix bug when accessing localizations for named search methods
+
+Changes since 0.9.8 (2010-10-20):
+  * ARel 2.x and Rails 3.0.2 compatability
+  * sort_link uses search_key from builder. Search_key defaults to "search"
+  * sort_link will localize attribute names.
+  * You can now create two scopes on your model named sort_by_something_asc
+    and sort_by_something_desc, and sort_link will then allow you to specify
+    :something as a parameter, then use your scope to perform custom sorting.
+
+Changes since 0.9.7 (2010-10-12):
+  * Play nicely regardless of MetaWhere/MetaSearch load order.
+  * Big fix - stop altering the supplied hash in Builder#build.
+
+Changes since 0.9.6 (2010-09-29):
+  * Support _or_-separated conditions. I'm not crazy about 'em, but it's
+    an oft-requested feature.
+  * Support search on polymorphic belongs_to associations. Uses the same
+    syntax users of Searchlogic are familiar with, association_classname_type.
+    For example: commentable_article_type_contains
+  * Join using left outer joins instead of inner joins. This lets you do
+    some interesting things like search for all articles with no comments via
+    comments_id_is_null.
+  * No longer define method on the metaclass - stick to standard method_missing
+    for both correctness and performance.
+
+Changes since 0.9.5 (2010-09-28):
+  * Fix issue with formatters supplied as strings
+
+Changes since 0.9.4 (2010-09-18):
+  * Rename check_boxes and collection_check_boxes to checks and
+    collection_checks. Alias to the old names if not already taken. This
+    is to avoid conflicts with SimpleForm.
+
+Changes since 0.9.3 (2010-09-08):
+  * Minor documentation fixes.
+  * Add sort_link helper to FormBuilder, to spare keystrokes if sort_links
+    are being added inside the context of the form_for of the search.
+
+Changes since 0.9.2 (2010-08-25):
+  * Update dependencies for Rails 3 final.
+
+Changes since 0.9.1 (2010-08-24):
+  * Fix time column casts to account for current time zone.
+
+Changes since 0.9.0 (2010-08-24):
+  * Fix the missing "2" in the Rails 3.0.0.rc2 dependency. Sorry!
+
+Changes since 0.5.4 (2010-07-28):
+  * Fix equals Where against boolean columns
+  * Add is_true/is_false for booleans, is_present/is_blank for other types
+  * Add is_null/is_not_null for all types
+  * Remove deprecated metasearch_exclude_attr and friends
+  * delegate #size and #length to relation
+
+Changes since 0.5.3 (2010-07-26):
+  * Add is_true/is_false for boolean columns
+  * Add is_present and is_blank for string/numeric columns
+  * Add is_null and is_not_null for all columns
+  * Fix behavior of equals when used with boolean columns.
+
+Changes since 0.5.2 (2010-07-22):
+  * Handle nested/namespaced form_for better. Formerly, you could use
+    "form_for @search" in a view, but not "form_for [:admin, @search]"
+
+Changes since 0.5.1 (2010-07-20):
+  * Fix fallback for failed cast via to_time or to_date
+  * add :cast option for custom Wheres, allowing a where to override
+    the default cast of the incoming parameters.
+
+Changes since 0.5.0 (2010-06-08):
+  * Fix searching against relations derived from a has_many :through
+    association

data/Gemfile

@@ -0,0 +1,12 @@
+source :rubygems
+
+# Don't do a "gemspec" here. Seriously. It jacks up Jeweler.
+
+gem "activerecord", "~> 3.1"
+gem "activesupport", "~> 3.1"
+gem "polyamorous", "~> 0.5.0"
+gem "actionpack", "~> 3.1"
+
+group :development do
+  gem "shoulda", "~> 2.11"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ernie Miller
+
+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.rdoc

@@ -0,0 +1,438 @@
+= MetaSearch
+
+MetaSearch is extensible searching for your form_for enjoyment. It “wraps” one of your ActiveRecord models, providing methods that allow you to build up search conditions against that model, and has a few extra form helpers to simplify sorting and supplying multiple parameters to your condition methods as well.
+
+== NOTE
+
+The successor to MetaSearch is {Ransack}[http://github.com/ernie/ransack]. It's got features
+that MetaSearch doesn't, along with some API changes. I haven't had the time to dedicate to
+making it bulletproof yet, so I'm releasing a 1.1.x branch of MetaSearch to help with migrations
+to Rails 3.1.
+
+This is intended to be a stopgap measure.
+
+t's important to note that the long-term migration path for your apps should be toward
+Ransack, which is written in a more sane manner that will make supporting new versions
+of Rails much easier going forward.
+
+== Getting Started
+
+In your Gemfile:
+
+  gem "meta_search"  # Last officially released gem
+  # gem "meta_search", :git => "git://github.com/ernie/meta_search.git" # Track git repo
+
+or, to install as a plugin:
+
+  rails plugin install git://github.com/ernie/meta_search.git
+
+In your controller:
+
+  def index
+    @search = Article.search(params[:search])
+    @articles = @search.all   # load all matching records
+    # @articles = @search.relation # Retrieve the relation, to lazy-load in view
+    # @articles = @search.paginate(:page => params[:page]) # Who doesn't love will_paginate?
+  end
+
+In your view:
+
+  <%= form_for @search, :url => articles_path, :html => {:method => :get} do |f| %>
+    <%= f.label :title_contains %>
+    <%= f.text_field :title_contains %><br />
+    <%= f.label :comments_created_at_greater_than, 'With comments after' %>
+    <%= f.datetime_select :comments_created_at_greater_than, :include_blank => true %><br />
+    <!-- etc... -->
+    <%= f.submit %>
+  <% end %>
+
+Options for the search method are documented at MetaSearch::Searches::ActiveRecord.
+
+== "Wheres", and what they're good for
+
+Wheres are how MetaSearch does its magic. Wheres have a name (and possible aliases) which are
+appended to your model and association attributes. When you instantiate a MetaSearch::Builder
+against a model (manually or by calling your model's +search+ method) the builder responds to
+methods named for your model's attributes and associations, suffixed by the name of the Where.
+
+These are the default Wheres, broken down by the types of ActiveRecord columns they can search
+against:
+
+=== All data types
+
+* _equals_ (alias: _eq_) - Just as it sounds.
+* _does_not_equal_ (aliases: _ne_, _noteq_) - The opposite of equals, oddly enough.
+* _in_ - Takes an array, matches on equality with any of the items in the array.
+* _not_in_ (aliases: _ni_, _notin_) - Like above, but negated.
+* _is_null_ - The column has an SQL NULL value.
+* _is_not_null_ - The column contains anything but NULL.
+
+=== Strings
+
+* _contains_ (aliases: _like_, _matches_) - Substring match.
+* _does_not_contain_ (aliases: _nlike_, _nmatches_) - Negative substring match.
+* _starts_with_ (alias: _sw_) - Match strings beginning with the entered term.
+* _does_not_start_with_ (alias: _dnsw_) - The opposite of above.
+* _ends_with_ (alias: _ew_) - Match strings ending with the entered term.
+* _does_not_end_with_ (alias: _dnew_) - Negative of above.
+
+=== Numbers, dates, and times
+
+* _greater_than_ (alias: _gt_) - Greater than.
+* _greater_than_or_equal_to_ (aliases: _gte_, _gteq_) - Greater than or equal to.
+* _less_than_ (alias: _lt_) - Less than.
+* _less_than_or_equal_to_ (aliases: _lte_, _lteq_) - Less than or equal to.
+
+=== Booleans
+
+* _is_true_ - Is true. Useful for a checkbox like "only show admin users".
+* _is_false_ - The complement of _is_true_.
+
+=== Non-boolean data types
+
+* _is_present_ - As with _is_true_, useful with a checkbox. Not NULL or the empty string.
+* _is_blank_ - Returns records with a value of NULL or the empty string in the column.
+
+So, given a model like this...
+
+  class Article < ActiveRecord::Base
+    belongs_to :author
+    has_many :comments
+    has_many :moderations, :through => :comments
+  end
+
+...you might end up with attributes like <tt>title_contains</tt>,
+<tt>comments_title_starts_with</tt>, <tt>moderations_value_less_than</tt>,
+<tt>author_name_equals</tt>, and so on.
+
+Additionally, all of the above predicate types also have an _any and _all version, which
+expects an array of the corresponding parameter type, and requires any or all of the
+parameters to be a match, respectively. So:
+
+  Article.search :author_name_starts_with_any => ['Jim', 'Bob', 'Fred']
+
+will match articles authored by Jimmy, Bobby, or Freddy, but not Winifred.
+
+== Advanced usage
+
+=== Narrowing the scope of a search
+
+While the most common use case is to simply call Model.search(params[:search]), there
+may be times where you want to scope your search more tightly. For instance, only allowing
+users to search their own projects (assuming a current_user method returning the current user):
+
+  @search = current_user.projects.search(params[:search])
+
+Or, you can build up any relation you like and call the search method on that object:
+
+  @projects_with_awesome_users_search =
+    Project.joins(:user).where(:users => {:awesome => true}).search(params[:search])
+
+=== ORed conditions
+
+If you'd like to match on one of several possible columns, you can do this:
+
+  <%= f.text_field :title_or_description_contains %>
+  <%= f.text_field :title_or_author_name_starts_with %>
+
+Caveats:
+
+* Only one match type is supported. You <b>can't</b> do
+  <tt>title_matches_or_description_starts_with</tt> for instance.
+* If you're matching across associations, remember that the associated table will be
+  INNER JOINed, therefore limiting results to those that at least have a corresponding
+  record in the associated table.
+
+=== Compound conditions (any/all)
+
+All Where types automatically get an "any" and "all" variant. This has the same name and
+aliases as the original, but is suffixed with _any and _all, for an "OR" or "AND" search,
+respectively. So, if you want to provide the user with 5 different search boxes to enter
+possible article titles:
+
+  <%= f.multiparameter_field :title_contains_any,
+        *5.times.inject([]) {|a, b| a << {:field_type => :text_field}} +
+        [:size => 10] %>
+
+=== Multi-level associations
+
+MetaSearch will allow you to traverse your associations in one form, generating the
+necessary joins along the way. If you have the following models...
+
+  class Company < ActiveRecord::Base
+    has_many :developers
+  end
+
+  class Developer < ActiveRecord::Base
+    belongs_to :company
+    has_many :notes
+  end
+
+...you can do this in your form to search your companies by developers with certain notes:
+
+  <%= f.text_field :developers_notes_note_contains %>
+
+You can travel forward and back through the associations, so this would also work (though
+be entirely pointless in this case):
+
+  <%= f.text_field :developers_notes_developer_company_name_contains %>
+
+However, to prevent abuse, this is limited to associations of a total "depth" of 5 levels.
+This means that while starting from a Company model, as above, you could do
+Company -> :developers -> :notes -> :developer -> :company, which has gotten you right
+back where you started, but "travels" through 5 models total.
+
+In the case of polymorphic belongs_to associations, things work a bit differently. Let's say
+you have the following models:
+
+  class Article < ActiveRecord::Base
+    has_many :comments, :as => :commentable
+  end
+
+  class Post < ActiveRecord::Base
+    has_many :comments, :as => :commentable
+  end
+
+  class Comment < ActiveRecord::Base
+    belongs_to :commentable, :polymorphic => true
+    validates_presence_of :body
+  end
+
+Your first instinct might be to set up a text field for :commentable_body_contains, but
+you can't do this. MetaSearch would have no way to know which class lies on the other side
+of the polymorphic association, so it wouldn't be able to join the correct tables.
+
+Instead, you'll follow a convention Searchlogic users are already familiar with, using the
+name of the polymorphic association, then the underscored class name (AwesomeClass becomes
+awesome_class), then the delimiter "type", to tell MetaSearch anything that follows is an
+attribute name. For example:
+
+  <%= f.text_field :commentable_article_type_body_contains %>
+
+If you'd like to match on multiple types of polymorphic associations, you can join them
+with \_or_, just like any other conditions:
+
+  <%= f.text_field :commentable_article_type_body_or_commentable_post_type_body_contains %>
+
+It's not pretty, but it works. Alternately, consider creating a custom search method as
+described below to save yourself some typing if you're creating a lot of these types of
+search fields.
+
+=== Adding a new Where
+
+If none of the built-in search criteria work for you, you can add new Wheres. To do so,
+create an initializer (<tt>/config/initializers/meta_search.rb</tt>, for instance) and add lines
+like:
+
+  MetaSearch::Where.add :between, :btw,
+    :predicate => :in,
+    :types => [:integer, :float, :decimal, :date, :datetime, :timestamp, :time],
+    :formatter => Proc.new {|param| Range.new(param.first, param.last)},
+    :validator => Proc.new {|param|
+      param.is_a?(Array) && !(param[0].blank? || param[1].blank?)
+    }
+
+See MetaSearch::Where for info on the supported options.
+
+=== Accessing custom search methods (and named scopes!)
+
+MetaSearch can be given access to any class method on your model to extend its search capabilities.
+The only rule is that the method must return an ActiveRecord::Relation so that MetaSearch can
+continue to extend the search with other attributes. Conveniently, scopes (formerly "named scopes")
+do this already.
+
+Consider the following model:
+
+  class Company < ActiveRecord::Base
+    has_many :slackers, :class_name => "Developer", :conditions => {:slacker => true}
+    scope :backwards_name, lambda {|name| where(:name => name.reverse)}
+    scope :with_slackers_by_name_and_salary_range,
+      lambda {|name, low, high|
+        joins(:slackers).where(:developers => {:name => name, :salary => low..high})
+      }
+  end
+
+To allow MetaSearch access to a model method, including a named scope, just use
+<tt>search_methods</tt> in the model:
+
+  search_methods :backwards_name
+
+This will allow you to add a text field named :backwards_name to your search form, and
+it will behave as you might expect.
+
+In the case of the second scope, we have multiple parameters to pass in, of different
+types. We can pass the following to <tt>search_methods</tt>:
+
+  search_methods :with_slackers_by_name_and_salary_range,
+    :splat_param => true, :type => [:string, :integer, :integer]
+
+MetaSearch needs us to tell it that we don't want to keep the array supplied to it as-is, but
+"splat" it when passing it to the model method. Regarding <tt>:types</tt>: In this case,
+ActiveRecord would have been smart enough to handle the typecasting for us, but I wanted to
+demonstrate how we can tell MetaSearch that a given parameter is of a specific database "column type." This is just a hint MetaSearch uses in the same way it does when casting "Where" params based
+on the DB column being searched. It's also important so that things like dates get handled
+properly by FormBuilder.
+
+=== multiparameter_field
+
+The example Where above adds support for a "between" search, which requires an array with
+two parameters. These can be passed using Rails multiparameter attributes. To make life easier,
+MetaSearch adds a helper for this:
+
+  <%= f.multiparameter_field :moderations_value_between,
+      {:field_type => :text_field}, {:field_type => :text_field}, :size => 5 %>
+
+<tt>multiparameter_field</tt> works pretty much like the other FormBuilder helpers, but it
+lets you sandwich a list of fields, each in hash format, between the attribute and the usual
+options hash. See MetaSearch::Helpers::FormBuilder for more info.
+
+=== checks and collection_checks
+
+If you need to get an array into your where, and you don't care about parameter order,
+you might choose to use a select or collection_select with multiple selection enabled,
+but everyone hates multiple selection boxes. MetaSearch adds a couple of additional
+helpers, +checks+ and +collection_checks+ to handle multiple selections in a
+more visually appealing manner. They can be called with or without a block. Without a
+block, you get an array of MetaSearch::Check objects to do with as you please.
+
+With a block, each check is yielded to your template, like so:
+
+  <h4>How many heads?</h4>
+  <ul>
+    <% f.checks :number_of_heads_in,
+      [['One', 1], ['Two', 2], ['Three', 3]], :class => 'checkboxy' do |check| %>
+      <li>
+        <%= check.box %>
+        <%= check.label %>
+      </li>
+    <% end %>
+  </ul>
+
+Again, full documentation is in MetaSearch::Helpers::FormBuilder.
+
+=== Sorting columns
+
+If you'd like to sort by a specific column in your results (the attributes of the base model)
+or an association column then supply the <tt>meta_sort</tt> parameter in your form.
+The parameter takes the form <tt>column.direction</tt> where +column+ is the column name or
+underscore-separated association_column combination, and +direction+ is one of "asc" or "desc"
+for ascending or descending, respectively.
+
+Normally, you won't supply this parameter yourself, but instead will use the helper method
+<tt>sort_link</tt> in your views, like so:
+
+  <%= sort_link @search, :title %>
+
+Or, if in the context of a form_for against a MetaSearch::Builder:
+
+  <%= f.sort_link :title %>
+
+The <tt>@search</tt> object is the instance of MetaSearch::Builder you got back earlier from
+your controller. The other required parameter is the attribute name itself. Optionally,
+you can provide a string as a 3rd parameter to override the default link name, and then
+additional hashed for the +options+ and +html_options+ hashes for link_to.
+
+By default, the link that is created will sort by the given column in ascending order when first clicked. If you'd like to reverse this (so the first click sorts the results in descending order), you can pass +:default_order => :desc+ in the options hash, like so:
+
+  <%= sort_link @search, :ratings, "Highest Rated", :default_order => :desc %>
+
+You can sort by more than one column as well, by creating a link like:
+
+  <%= sort_link :name_and_salary %>
+
+If you'd like to do a custom sort, you can do so by setting up two scopes in your model:
+
+  scope :sort_by_custom_name_asc, order('custom_name ASC')
+  scope :sort_by_custom_name_desc, order('custom_name DESC')
+
+You can then do <tt>sort_link @search, :custom_name</tt> and it will work as you expect.
+
+All <tt>sort_link</tt>-generated links will have the CSS class sort_link, as well as a
+directional class (ascending or descending) if the link is for a currently sorted column,
+for your styling enjoyment.
+
+This feature should hopefully help out those of you migrating from Searchlogic, and a thanks
+goes out to Ben Johnson for the HTML entities used for the up and down arrows, which provide
+a nice default look.
+
+=== Including/excluding attributes and associations
+
+If you'd like to allow only certain associations or attributes to be searched, you can do
+so inside your models
+
+  class Article < ActiveRecord::Base
+    attr_searchable :some_public_data, :some_more_searchable_stuff
+    assoc_searchable :search_this_association_why_dontcha
+  end
+
+If you'd rather blacklist attributes and associations rather than whitelist, use the
+<tt>attr_unsearchable</tt> and <tt>assoc_unsearchable</tt> method instead. If a
+whitelist is supplied, it takes precedence.
+
+Excluded attributes on a model will be honored across associations, so if an Article
+<tt>has_many :comments</tt> and the Comment model looks something like this:
+
+  class Comment < ActiveRecord::Base
+    validates_presence_of :user_id, :body
+    attr_unsearchable :user_id
+  end
+
+Then your call to <tt>Article.search</tt> will allow <tt>:comments_body_contains</tt>
+but not <tt>:comments_user_id_equals</tt> to be passed.
+
+=== Conditional access to searches
+
+<tt>search_methods</tt>, <tt>attr_searchable</tt>, <tt>attr_unsearchable</tt>,
+<tt>assoc_searchable</tt>, and <tt>assoc_unsearchable</tt> all accept an <tt>:if</tt>
+option. If present, it should specify a Proc (or other object responding to <tt>call</tt>)
+that accepts a single parameter. This parameter will be the instance of the MetaSearch::Builder
+that gets created by a call to Model.search. Any unused search options (the second hash param)
+that get passed to Model.search will be available via the Builder object's <tt>options</tt>
+reader, and can be used for access control via this proc/object.
+
+Example:
+
+  assoc_unsearchable :notes,
+                     :if => proc {|s| s.options[:access] == 'blocked' || !s.options[:access]}
+
+=== Localization
+
+MetaSearch supports i18n localization in a few different ways. Consider this abbreviated
+example "flanders" locale:
+
+  flanders:
+    activerecord:
+      attributes:
+        company:
+          name: "Company name-diddly"
+        developer:
+          name: "Developer name-diddly"
+          salary: "Developer salary-doodly"
+    meta_search:
+      or: 'or-diddly'
+      predicates:
+        contains: "%{attribute} contains-diddly"
+        equals: "%{attribute} equals-diddly"
+      attributes:
+        company:
+          reverse_name: "Company reverse name-diddly"
+        developer:
+          name_contains: "Developer name-diddly contains-aroonie"
+
+First, MetaSearch will use a key found under meta_search.attributes.model_name.attribute_name,
+if it exists. As a fallback, it will use a localization based on the predicate type, along with
+the usual ActiveRecord attribute localization (the activerecord.attributes.model_name keys above).
+Additionally, a localized "or" can be specified for multi-column searches.
+
+== Contributions
+
+There are several ways you can help MetaSearch continue to improve.
+
+* Use MetaSearch in your real-world projects and {submit bug reports or feature suggestions}[http://metautonomous.lighthouseapp.com/projects/53012-metasearch/].
+* Better yet, if you’re so inclined, fix the issue yourself and submit a patch! Or you can {fork the project on GitHub}[http://github.com/ernie/meta_search] and send me a pull request (please include tests!)
+* If you like MetaSearch, spread the word. More users == more eyes on code == more bugs getting found == more bugs getting fixed (hopefully!)
+* Lastly, if MetaSearch has saved you hours of development time on your latest Rails gig, and you’re feeling magnanimous, please consider {making a donation}[http://pledgie.com/campaigns/9647] to the project. I have spent hours of my personal time coding and supporting MetaSearch, and your donation would go a great way toward justifying that time spent to my loving wife. :)
+
+== Copyright
+
+Copyright (c) 2010 {Ernie Miller}[http://metautonomo.us]. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,69 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "meta_search"
+    gem.summary = %Q{Object-based searching (and more) for simply creating search forms.}
+    gem.description = %Q{
+      Allows simple search forms to be created against an AR3 model
+      and its associations, has useful view helpers for sort links
+      and multiparameter fields as well.
+    }
+    gem.email = "ernie@metautonomo.us"
+    gem.homepage = "http://metautonomo.us/projects/metasearch/"
+    gem.authors = ["Ernie Miller"]
+    gem.post_install_message = <<END
+
+*** Thanks for installing MetaSearch! ***
+Be sure to check out http://metautonomo.us/projects/metasearch/ for a
+walkthrough of MetaSearch's features, and click the donate button if
+you're feeling especially appreciative. It'd help me justify this
+"open source" stuff to my lovely wife. :)
+
+END
+  end
+  Jeweler::RubygemsDotOrgTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.libs << 'vendor/rails/activerecord/lib'
+  test.libs << 'vendor/rails/activesupport/lib'
+  test.libs << 'vendor/rails/actionpack/lib'
+  test.libs << 'vendor/arel/lib'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+# Don't check dependencies on test, we're using vendored libraries
+# task :test => :check_dependencies
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "meta_search #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.3