meta_search_hub 1.1.3

data/lib/meta_search/where.rb

@@ -0,0 +1,264 @@
+require 'meta_search/exceptions'
+
+module MetaSearch
+  # 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.
+  class Where
+    attr_reader :name, :aliases, :types, :cast, :predicate, :formatter, :validator
+    def initialize(where)
+      if [String,Symbol].include?(where.class)
+        where = Where.get(where) or raise ArgumentError("A where could not be instantiated for the argument #{where}")
+      end
+      @name = where[:name]
+      @aliases = where[:aliases]
+      @types = where[:types]
+      @cast = where[:cast]
+      @predicate = where[:predicate]
+      @validator = where[:validator]
+      @formatter = where[:formatter]
+      @splat_param = where[:splat_param]
+      @skip_compounds = where[:skip_compounds]
+    end
+
+    def splat_param?
+      !!@splat_param
+    end
+
+    def skip_compounds?
+      !!@skip_compounds
+    end
+
+    # Format a parameter for searching using the Where's defined formatter.
+    def format_param(param)
+      formatter.call(param)
+    end
+
+    # Validate the parameter for use in a search using the Where's defined validator.
+    def validate(param)
+      validator.call(param)
+    end
+
+    # Evaluate the Where for the given relation, attribute, and parameter(s)
+    def evaluate(relation, attributes, param)
+      if splat_param?
+        conditions = attributes.map {|a| a.send(predicate, *format_param(param))}
+      else
+        conditions = attributes.map {|a| a.send(predicate, format_param(param))}
+      end
+
+      relation.where(conditions.inject(nil) {|memo, c| memo ? memo.or(c) : c})
+    end
+
+    class << self
+      # At application initialization, you can add additional custom Wheres to the mix.
+      # in your application's <tt>config/initializers/meta_search.rb</tt>, place lines
+      # like this:
+      #
+      #   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?)
+      #     }
+      #
+      # The first options are all names for the where. Well, the first is a name, the rest
+      # are aliases, really. They will determine the suffix you will use to access your Where.
+      #
+      # <tt>types</tt> is an array of types the comparison is valid for. The where will not
+      # be available against columns that are not one of these types. Default is +ALL_TYPES+,
+      # Which is one of several MetaSearch constants available for type assignment (the others
+      # being +DATES+, +TIIMES+, +STRINGS+, and +NUMBERS+).
+      #
+      # <tt>predicate</tt> is the Arel::Attribute predication (read: conditional operator) used
+      # for the comparison. Default is :eq, or equality.
+      #
+      # <tt>formatter</tt> is the Proc that will do any formatting to the variables to be substituted.
+      # The default proc is <tt>{|param| param}</tt>, which doesn't really do anything. If you pass a
+      # string, it will be +eval+ed in the context of this Proc.
+      #
+      # For example, this is the definition of the "contains" Where:
+      #
+      #   ['contains', 'like', {:types => STRINGS, :predicate => :matches, :formatter => '"%#{param}%"'}]
+      #
+      # Be sure to single-quote the string, so that variables aren't interpolated until later. If in doubt,
+      # just use a Proc.
+      #
+      # <tt>validator</tt> is the Proc that will be used to check whether a parameter supplied to the
+      # Where is valid. If it is not valid, it won't be used in the query. The default is
+      # <tt>{|param| !param.blank?}</tt>, so that empty parameters aren't added to the search, but you
+      # can get more complex if you desire, like the one in the between example, above.
+      #
+      # <tt>splat_param</tt>, if true, will cause the parameters sent to the predicate in question
+      # to be splatted (converted to an argument list). This is not normally useful and defaults to
+      # false, but is used when automatically creating compound Wheres (*_any, *_all) so that the
+      # Arel attribute method gets the correct parameter list.
+      #
+      # <tt>skip_compounds</tt> will prevent creation of compound condition methods (ending in
+      # _any_ or _all_) for situations where they wouldn't make sense, such as the built-in
+      # conditions <tt>is_true</tt> and <tt>is_false</tt>.
+      #
+      # <tt>cast</tt> will override the normal cast of the parameter when using this Where
+      # condition. Normally, the value supplied to a condition is cast to the type of the column
+      # it's being compared against. In cases where this isn't desirable, because the value you
+      # intend to accept isn't the same kind of data you'll be comparing against, you can override
+      # that cast here, using one of the standard DB type symbols such as :integer, :string, :boolean
+      # and so on.
+      def add(*args)
+        where = create_where_from_args(*args)
+        create_where_compounds_for(where) unless where.skip_compounds?
+      end
+
+      # Returns the complete array of Wheres
+      def all
+        @@wheres
+      end
+
+      # Get the where matching a method or predicate.
+      def get(method_id_or_predicate)
+        return nil unless where_key = @@wheres.keys.
+          sort {|a,b| b.length <=> a.length}.
+          detect {|n| method_id_or_predicate.to_s.match(/#{n}=?$/)}
+        where = @@wheres[where_key]
+        where = @@wheres[where] if where.is_a?(String)
+        where
+      end
+
+      # Set the wheres to their default values, removing any customized settings.
+      def initialize_wheres
+        @@wheres = {}
+        DEFAULT_WHERES.each do |where|
+          add(*where)
+        end
+      end
+
+      private
+
+      # "Creates" the Where by adding it (and its aliases) to the current hash of wheres. It then
+      # instantiates a Where and returns it for use.
+      def create_where_from_args(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        args = args.compact.flatten.map {|a| a.to_s }
+        raise ArgumentError, "Name parameter required" if args.blank?
+        opts[:name] ||= args.first
+        opts[:types] ||= ALL_TYPES
+        opts[:types] = [opts[:types]].flatten
+        opts[:cast] = opts[:cast]
+        opts[:predicate] ||= :eq
+        opts[:splat_param] ||= false
+        opts[:skip_compounds] ||= false
+        opts[:formatter] ||= Proc.new {|param| param}
+        if opts[:formatter].is_a?(String)
+          formatter = opts[:formatter]
+          opts[:formatter] = Proc.new {|param| eval formatter}
+        end
+        unless opts[:formatter].respond_to?(:call)
+          raise ArgumentError, "Invalid formatter for #{opts[:name]}, should be a Proc or String."
+        end
+        opts[:validator] ||= Proc.new {|param| !param.blank?}
+        unless opts[:validator].respond_to?(:call)
+          raise ArgumentError, "Invalid validator for #{opts[:name]}, should be a Proc."
+        end
+        opts[:aliases] ||= [args - [opts[:name]]].flatten
+        @@wheres ||= {}
+        if @@wheres.has_key?(opts[:name])
+          raise ArgumentError, "\"#{opts[:name]}\" is not available for use as a where name."
+        end
+        @@wheres[opts[:name]] = opts
+        opts[:aliases].each do |a|
+          if @@wheres.has_key?(a)
+            opts[:aliases].delete(a)
+          else
+            @@wheres[a] = opts[:name]
+          end
+        end
+        new(opts[:name])
+      end
+
+      # Takes the provided +where+ param and derives two additional Wheres from it, with the
+      # name appended by _any/_all. These will use Arel's grouped predicate methods (matching
+      # the same naming convention) to be invoked instead, with a list of possible/required
+      # matches.
+      def create_where_compounds_for(where)
+        ['any', 'all'].each do |compound|
+          args = [where.name, *where.aliases].map {|n| "#{n}_#{compound}"}
+          create_where_from_args(*args + [{
+            :types => where.types,
+            :predicate => "#{where.predicate}_#{compound}".to_sym,
+            # Only use valid elements in the array
+            :formatter => Proc.new {|param|
+              param.select {|p| where.validator.call(p)}.map {|p| where.formatter.call(p)}
+            },
+            # Compound where is valid if it has at least one element which is valid
+            :validator => Proc.new {|param|
+              param.is_a?(Array) &&
+              !param.select {|p| where.validator.call(p)}.blank?}
+            }]
+          )
+        end
+      end
+    end
+  end
+
+  Where.initialize_wheres
+end

data/lib/meta_search.rb

@@ -0,0 +1,58 @@
+module MetaSearch
+  NUMBERS = [:integer, :float, :decimal]
+  STRINGS = [:string, :text, :binary]
+  DATES = [:date]
+  TIMES = [:datetime, :timestamp, :time]
+  BOOLEANS = [:boolean]
+  ALL_TYPES = NUMBERS + STRINGS + DATES + TIMES + BOOLEANS
+
+  # Change this only if you know what you're doing. It's here for your protection.
+  MAX_JOIN_DEPTH = 5
+
+  DEFAULT_WHERES = [
+    ['equals', 'eq', {:validator => Proc.new {|param| !param.blank? || (param == false)}}],
+    ['does_not_equal', 'ne', 'not_eq', {:types => ALL_TYPES, :predicate => :not_eq}],
+    ['contains', 'like', 'matches', {:types => STRINGS, :predicate => :matches, :formatter => '"%#{param}%"'}],
+    ['does_not_contain', 'nlike', 'not_matches', {:types => STRINGS, :predicate => :does_not_match, :formatter => '"%#{param}%"'}],
+    ['starts_with', 'sw', {:types => STRINGS, :predicate => :matches, :formatter => '"#{param}%"'}],
+    ['does_not_start_with', 'dnsw', {:types => STRINGS, :predicate => :does_not_match, :formatter => '"#{param}%"'}],
+    ['ends_with', 'ew', {:types => STRINGS, :predicate => :matches, :formatter => '"%#{param}"'}],
+    ['does_not_end_with', 'dnew', {:types => STRINGS, :predicate => :does_not_match, :formatter => '"%#{param}"'}],
+    ['greater_than', 'gt', {:types => (NUMBERS + DATES + TIMES), :predicate => :gt}],
+    ['less_than', 'lt', {:types => (NUMBERS + DATES + TIMES), :predicate => :lt}],
+    ['greater_than_or_equal_to', 'gte', 'gteq', {:types => (NUMBERS + DATES + TIMES), :predicate => :gteq}],
+    ['less_than_or_equal_to', 'lte', 'lteq', {:types => (NUMBERS + DATES + TIMES), :predicate => :lteq}],
+    ['in', {:types => ALL_TYPES, :predicate => :in}],
+    ['not_in', 'ni', 'not_in', {:types => ALL_TYPES, :predicate => :not_in}],
+    ['is_true', {:types => BOOLEANS, :skip_compounds => true}],
+    ['is_false', {:types => BOOLEANS, :skip_compounds => true, :formatter => Proc.new {|param| !param}}],
+    ['is_present', {:types => (ALL_TYPES - BOOLEANS), :predicate => :not_eq_all, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| [nil, '']}}],
+    ['is_blank', {:types => (ALL_TYPES - BOOLEANS), :predicate => :eq_any, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| [nil, '']}}],
+    ['is_null', {:types => ALL_TYPES, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| nil}}],
+    ['is_not_null', {:types => ALL_TYPES, :predicate => :not_eq, :skip_compounds => true, :cast => :boolean, :formatter => Proc.new {|param| nil}}]
+  ]
+
+  RELATION_METHODS = [
+    # Query construction
+    :joins, :includes, :select, :order, :where, :having, :group,
+    # Results, debug, array methods
+    :to_a, :all, :length, :size, :to_sql, :debug_sql, :paginate, :page,
+    :find_each, :first, :last, :each, :arel, :in_groups_of, :group_by,
+    # Calculations
+    :count, :average, :minimum, :maximum, :sum
+  ]
+end
+
+require 'active_record'
+require 'active_support'
+require 'action_view'
+require 'action_controller'
+require 'meta_search/searches/active_record'
+require 'meta_search/helpers'
+
+I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'meta_search', 'locale', '*.yml')]
+
+ActiveRecord::Base.send(:include, MetaSearch::Searches::ActiveRecord)
+ActionView::Helpers::FormBuilder.send(:include, MetaSearch::Helpers::FormBuilder)
+ActionController::Base.helper(MetaSearch::Helpers::UrlHelper)
+ActionController::Base.helper(MetaSearch::Helpers::FormHelper)

data/meta_search.gemspec

@@ -0,0 +1,90 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = 'meta_search_hub'
+  s.version = "1.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ernie Miller"]
+  s.date = "2012-02-02"
+  s.description = "\n      Allows simple search forms to be created against an AR3 model\n      and its associations, has useful view helpers for sort links\n      and multiparameter fields as well.\n    "
+  s.email = "ernie@metautonomo.us"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".gitmodules",
+    "CHANGELOG",
+    "Gemfile",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/meta_search.rb",
+    "lib/meta_search/builder.rb",
+    "lib/meta_search/exceptions.rb",
+    "lib/meta_search/helpers.rb",
+    "lib/meta_search/helpers/form_builder.rb",
+    "lib/meta_search/helpers/form_helper.rb",
+    "lib/meta_search/helpers/url_helper.rb",
+    "lib/meta_search/locale/en.yml",
+    "lib/meta_search/method.rb",
+    "lib/meta_search/model_compatibility.rb",
+    "lib/meta_search/searches/active_record.rb",
+    "lib/meta_search/utility.rb",
+    "lib/meta_search/where.rb",
+    "meta_search.gemspec",
+    "test/fixtures/companies.yml",
+    "test/fixtures/company.rb",
+    "test/fixtures/data_type.rb",
+    "test/fixtures/data_types.yml",
+    "test/fixtures/developer.rb",
+    "test/fixtures/developers.yml",
+    "test/fixtures/developers_projects.yml",
+    "test/fixtures/note.rb",
+    "test/fixtures/notes.yml",
+    "test/fixtures/project.rb",
+    "test/fixtures/projects.yml",
+    "test/fixtures/schema.rb",
+    "test/helper.rb",
+    "test/locales/es.yml",
+    "test/locales/flanders.yml",
+    "test/test_search.rb",
+    "test/test_view_helpers.rb"
+  ]
+  s.homepage = "http://metautonomo.us/projects/metasearch/"
+  s.post_install_message = "\n*** Thanks for installing MetaSearch! ***\nBe sure to check out http://metautonomo.us/projects/metasearch/ for a\nwalkthrough of MetaSearch's features, and click the donate button if\nyou're feeling especially appreciative. It'd help me justify this\n\"open source\" stuff to my lovely wife. :)\n\n"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.15"
+  s.summary = "Object-based searching (and more) for simply creating search forms."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.1"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.1"])
+      s.add_runtime_dependency(%q<polyamorous>, ["~> 0.5.0"])
+      s.add_runtime_dependency(%q<actionpack>, ["~> 3.1"])
+      s.add_development_dependency(%q<shoulda>, ["~> 2.11"])
+    else
+      s.add_dependency(%q<activerecord>, ["~> 3.1"])
+      s.add_dependency(%q<activesupport>, ["~> 3.1"])
+      s.add_dependency(%q<polyamorous>, ["~> 0.5.0"])
+      s.add_dependency(%q<actionpack>, ["~> 3.1"])
+      s.add_dependency(%q<shoulda>, ["~> 2.11"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, ["~> 3.1"])
+    s.add_dependency(%q<activesupport>, ["~> 3.1"])
+    s.add_dependency(%q<polyamorous>, ["~> 0.5.0"])
+    s.add_dependency(%q<actionpack>, ["~> 3.1"])
+    s.add_dependency(%q<shoulda>, ["~> 2.11"])
+  end
+end
+

data/test/fixtures/companies.yml

@@ -0,0 +1,17 @@
+initech:
+  name      : Initech
+  id        : 1
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00
+
+aos:
+  name: Advanced Optical Solutions
+  id  : 2
+  created_at: 2004-02-01 08:00
+  updated_at: 2004-02-01 08:00
+
+mission_data:
+  name: Mission Data
+  id  : 3
+  created_at: 1996-09-21 08:00
+  updated_at: 1996-09-21 08:00

data/test/fixtures/company.rb

@@ -0,0 +1,22 @@
+class Company < ActiveRecord::Base
+  has_many :developers
+  has_many :developer_notes, :through => :developers, :source => :notes
+  has_many :slackers, :class_name => "Developer", :conditions => {:slacker => true}
+  has_many :notes, :as => :notable
+  has_many :data_types
+
+  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})
+    }
+  search_methods :backwards_name, :backwards_name_as_string, :if => proc {|s| s.options[:user] != 'blocked'}
+  search_methods :with_slackers_by_name_and_salary_range,
+    :splat_param => true, :type => [:string, :integer, :integer]
+  attr_unsearchable :updated_at, :if => proc {|s| s.options[:user] == 'blocked' || !s.options[:user]}
+  assoc_unsearchable :notes, :if => proc {|s| s.options[:user] == 'blocked' || !s.options[:user]}
+
+  def self.backwards_name_as_string(name)
+    name.reverse
+  end
+end

data/test/fixtures/data_type.rb

@@ -0,0 +1,5 @@
+class DataType < ActiveRecord::Base
+  belongs_to :company
+  attr_unsearchable :str
+  attr_protected :str
+end

data/test/fixtures/data_types.yml

@@ -0,0 +1,15 @@
+<% 1.upto(9) do |n| %>
+dt_<%= n %>:
+  company_id: <%= n % 3 + 1 %>
+  str       : This string has <%= n %> exclamation points<%= '!' * n %>
+  txt       : <%= 'This is some text that may or may not repeat based on the value of n.' * n %>
+  int       : <%= n ** 3 %>
+  flt       : <%= n.to_f / 2.0 %>
+  dec       : <%= n.to_f ** (n + 0.1) %>
+  dtm       : <%= (Time.local(2009, 12, 24) + 86400 * n).in_time_zone.to_s(:db) %>
+  tms       : <%= (Time.local(2009, 12, 24) + 86400 * n).in_time_zone.to_s(:db) %>
+  tim       : <%= Time.local(2000, 01, 01, n+8, n).in_time_zone.to_s(:db) %>
+  dat       : <%= (Date.new(2009, 12, 24) + n).strftime("%Y-%m-%d") %>
+  bin       : <%= "BLOB#{n}" * n %>
+  bln       : <%= n % 2 > 0 ? true : false %>
+<% end %>

data/test/fixtures/developer.rb

@@ -0,0 +1,11 @@
+class Developer < ActiveRecord::Base
+  belongs_to :company
+  has_and_belongs_to_many :projects
+  has_many :notes, :as => :notable
+
+  attr_searchable :name, :salary, :if => proc {|s| !s.options[:user] || s.options[:user] == 'privileged'}
+  assoc_searchable :notes, :projects, :company, :if => proc {|s| !s.options[:user] || s.options[:user] == 'privileged'}
+
+  scope :sort_by_salary_and_name_asc, order('salary ASC, name ASC')
+  scope :sort_by_salary_and_name_desc, order('salary DESC, name DESC')
+end

data/test/fixtures/developers.yml

@@ -0,0 +1,62 @@
+peter:
+  id        : 1
+  company_id: 1
+  name      : Peter Gibbons
+  salary    : 100000
+  slacker   : true
+
+michael:
+  id        : 2
+  company_id: 1
+  name      : Michael Bolton
+  salary    : 70000
+  slacker   : false
+
+samir:
+  id        : 3
+  company_id: 1
+  name      : Samir Nagheenanajar
+  salary    : 65000
+  slacker   : false
+
+herb:
+  id        : 4
+  company_id: 2
+  name      : Herb Myers
+  salary    : 50000
+  slacker   : false
+
+dude:
+  id        : 5
+  company_id: 2
+  name      : Some Dude
+  salary    : 84000
+  slacker   : true
+
+ernie:
+  id        : 6
+  company_id: 3
+  name      : Ernie Miller
+  salary    : 45000
+  slacker   : true
+
+someone:
+  id        : 7
+  company_id: 3
+  name      : Someone Else
+  salary    : 70000
+  slacker   : true
+
+another:
+  id        : 8
+  company_id: 3
+  name      : Another Guy
+  salary    : 80000
+  slacker   : false
+
+forgetful:
+  id        : 9
+  company_id: 3
+  name      : Forgetful Notetaker
+  salary    : 40000
+  slacker   : false

data/test/fixtures/developers_projects.yml

@@ -0,0 +1,25 @@
+<% 1.upto(3) do |d| %>
+y2k_<%= d %>:
+  developer_id: <%= d %>
+  project_id  : 1
+<% end %>
+
+virus:
+  developer_id: 2
+  project_id  : 2
+  
+<% 1.upto(8) do |d| %>
+awesome_<%= d %>:
+  developer_id: <%= d %>
+  project_id  : 3
+<% end %>
+
+metasearch:
+  developer_id: 6
+  project_id  : 4
+
+<% 4.upto(8) do |d| %>
+another_<%= d %>:
+  developer_id: <%= d %>
+  project_id  : 5
+<% end %>

data/test/fixtures/note.rb

@@ -0,0 +1,3 @@
+class Note < ActiveRecord::Base
+  belongs_to :notable, :polymorphic => true
+end

data/test/fixtures/notes.yml

@@ -0,0 +1,79 @@
+peter:
+  notable_type: Developer
+  notable_id  : 1
+  note        : A straight shooter with upper management written all over him.
+  
+michael:
+  notable_type: Developer
+  notable_id  : 2
+  note        : Doesn't like the singer of the same name. The nerve!
+
+samir:
+  notable_type: Developer
+  notable_id  : 3
+  note        : Naga.... Naga..... Not gonna work here anymore anyway.
+
+herb:
+  notable_type: Developer
+  notable_id  : 4
+  note        : Will show you what he's doing.
+
+dude:
+  notable_type: Developer
+  notable_id  : 5
+  note        : Nothing of note.
+
+ernie:
+  notable_type: Developer
+  notable_id  : 6
+  note        : Complete slacker. Should probably be fired.
+
+someone:
+  notable_type: Developer
+  notable_id  : 7
+  note        : Just another developer.
+
+another:
+  notable_type: Developer
+  notable_id  : 8
+  note        : Placing a note in this guy's file for insubordination.
+
+initech:
+  notable_type: Company
+  notable_id  : 1
+  note        : Innovation + Technology!
+
+aos:
+  notable_type: Company
+  notable_id  : 2
+  note        : Advanced solutions of an optical nature.
+
+mission_data:
+  notable_type: Company
+  notable_id  : 3
+  note        : Best design + development shop in the 'ville.
+
+y2k:
+  notable_type: Project
+  notable_id  : 1
+  note        : It may have already passed but that's no excuse to be unprepared!
+
+virus:
+  notable_type: Project
+  notable_id  : 2
+  note        : It could bring the company to its knees.
+
+awesome:
+  notable_type: Project
+  notable_id  : 3
+  note        : This note is AWESOME!!!
+
+metasearch:
+  notable_type: Project
+  notable_id  : 4
+  note        : A complete waste of the developer's time.
+
+another:
+  notable_type: Project
+  notable_id  : 5
+  note        : This is another project note.

data/test/fixtures/project.rb

@@ -0,0 +1,4 @@
+class Project < ActiveRecord::Base
+  has_and_belongs_to_many :developers
+  has_many :notes, :as => :notable
+end