meta_search 0.3.0

data/lib/meta_search/searches/base.rb

@@ -0,0 +1,46 @@
+require 'meta_search/builder'
+
+module MetaSearch
+  module Searches
+    module Base
+      # Prepares the search to run against your model. Returns an instance of
+      # MetaSearch::Builder, which behaves pretty much like an ActiveRecord::Relation,
+      # in that it doesn't actually query the database until you do something that
+      # requires it to do so.
+      def search(opts = {})
+        opts ||= {} # to catch nil params
+        search_options = opts.delete(:search_options) || {}
+        builder = MetaSearch::Builder.new(self, search_options)
+        builder.build(opts)
+      end
+      
+      private
+      
+      # Excludes model attributes from searchability. This means that searches can't be created against
+      # these columns, whether the search is based on this model, or the model's attributes are being
+      # searched by association from another model. If a Comment <tt>belongs_to :article</tt> but declares
+      # <tt>metasearch_exclude_attr :user_id</tt> then <tt>Comment.search</tt> won't accept parameters
+      # like <tt>:user_id_equals</tt>, nor will an Article.search accept the parameter
+      # <tt>:comments_user_id_equals</tt>.
+      def metasearch_exclude_attr(*args)
+        args.each do |attr|
+          attr = attr.to_s
+          raise(ArgumentError, "No persisted attribute (column) named #{attr} in #{self}") unless self.columns_hash.has_key?(attr)
+          self._metasearch_exclude_attributes = (self._metasearch_exclude_attributes + [attr]).uniq
+        end
+      end
+      
+      # Excludes model associations from searchability. This mean that searches can't be created against
+      # these associations. An article that <tt>has_many :comments</tt> but excludes comments from
+      # searching by declaring <tt>metasearch_exclude_assoc :comments</tt> won't make any of the
+      # <tt>comments_*</tt> methods available.
+      def metasearch_exclude_assoc(*args)
+        args.each do |assoc|
+          assoc = assoc.to_s
+          raise(ArgumentError, "No such association #{assoc} in #{self}") unless self.reflect_on_all_associations.map {|a| a.name.to_s}.include?(assoc)
+          self._metasearch_exclude_associations = (self._metasearch_exclude_associations + [assoc]).uniq
+        end
+      end
+    end
+  end
+end

data/lib/meta_search/utility.rb

@@ -0,0 +1,85 @@
+require 'meta_search/exceptions'
+
+module MetaSearch
+  module Utility #:nodoc:
+    private
+    
+    def array_of_arrays?(vals)
+      vals.is_a?(Array) && vals.first.is_a?(Array)
+    end
+    
+    def array_of_dates?(vals)
+      vals.is_a?(Array) && vals.first.respond_to?(:to_time)
+    end
+    
+    def cast_attributes(type, vals)
+      if array_of_arrays?(vals)
+        vals.map! {|v| cast_attributes(type, v)}
+      # Need to make sure not to kill multiparam dates/times
+      elsif vals.is_a?(Array) && (array_of_dates?(vals) || !(DATES+TIMES).include?(type))
+        vals.map! {|v| cast_attribute(type, v)}
+      else
+        cast_attribute(type, vals)
+      end
+    end
+
+    def cast_attribute(type, val)
+      case type
+      when *STRINGS
+        val.respond_to?(:to_s) ? val.to_s : String.new(val)
+      when *DATES
+        if val.respond_to?(:to_date)
+          val.to_date
+        else
+          y, m, d = *[val].flatten
+          m ||= 1
+          d ||= 1
+          Date.new(y,m,d) rescue nil
+        end
+      when *TIMES
+        if val.respond_to?(:to_time)
+          val.to_time
+        else
+          y, m, d, hh, mm, ss = *[val].flatten
+          Time.zone.local(y, m, d, hh, mm, ss) rescue nil
+        end
+      when *BOOLEANS
+        ActiveRecord::ConnectionAdapters::Column.value_to_boolean(val)
+      when :integer
+        val.blank? ? nil : val.to_i
+      when :float
+        val.blank? ? nil : val.to_f
+      when :decimal
+        val.blank? ? nil : ActiveRecord::ConnectionAdapters::Column.value_to_decimal(val)
+      else
+        raise TypeCastError, "Unable to cast columns of type #{type}"
+      end
+    end
+    
+    def collapse_multiparameter_options(opts)
+      opts.each_key do |k|
+        if k.include?("(")
+          real_attribute, position = k.split(/\(|\)/)
+          cast = %w(a s i).include?(position.last) ? position.last : nil
+          position = position.to_i - 1
+          value = opts.delete(k)
+          opts[real_attribute] ||= []
+          opts[real_attribute][position] = if cast
+            (value.blank? && cast == 'i') ? nil : value.send("to_#{cast}")
+          else
+            value
+          end
+        end
+      end
+      opts
+    end
+    
+    def quote_table_name(name)
+      ActiveRecord::Base.connection.quote_table_name(name)
+    end
+    
+    def quote_column_name(name)
+      ActiveRecord::Base.connection.quote_column_name(name)
+    end
+  end
+end

data/lib/meta_search/where.rb

@@ -0,0 +1,174 @@
+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_ (alias: _ne_) - The opposite of equals, oddly enough.
+  # * _in_ - Takes an array, matches on equality with any of the items in the array.
+  # * _not_in_ (alias: _ni_) - Like above, but negated.
+  #
+  # === Strings
+  #
+  # * _contains_ (alias: _like_) - Substring match.
+  # * _does_not_contain_ (alias: _nlike_) - 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_ (alias: _gte_) - Greater than or equal to.
+  # * _less_than_ (alias: _lt_) - Less than.
+  # * _less_than_or_equal_to_ (alias: _lte_) - Less than or equal to.
+  #
+  # 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.
+  class Where
+    attr_reader :name, :aliases, :types, :condition, :substitutions, :formatter
+    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]
+      @condition = where[:condition]
+      @substitutions = where[:substitutions]
+      @formatter = where[:formatter]
+      @keep_arrays = where[:keep_arrays]
+    end
+    
+    def keep_arrays?
+      @keep_arrays
+    end
+    
+    # Checks that the given +value+ is valid to use for the substitutions of this where.
+    # Requires that there are the same number of parameters as substitutions, and none of'
+    # them is blank.
+    def valid_substitutions?(*values)
+      values.flatten! unless values.size > 1 || self.keep_arrays?
+      self.substitutions.count('?') == values.select {|v| !v.blank?}.size
+    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, {
+      #     :types =>  [:integer, :float, :decimal, :date, :datetime, :timestamp, :time],
+      #     :condition => 'BETWEEN',
+      #     :substitutions => '? AND ?',
+      #     :formatter => Proc.new {|param| param}
+      #   }
+      #
+      # 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>condition</tt> is the condition placed between the column and the substitutions, such as
+      # BETWEEN, IN, or =. Default is =.
+      #
+      # <tt>substitutions</tt> is the text that comes next. It's normally going to have some
+      # question marks in it (for variable substitution) if it's going to be of much use. The
+      # default is ?. Keep in mind if you use more than one ? MetaSearch will require an array
+      # be passed to the attribute for substitution.
+      #
+      # <tt>keep_arrays</tt> tells MetaSearch that if any arrays are received as parameters, they
+      # should be used as-is in the substitution, rather than flattened and passed as a list.
+      # For example, this is the definition of the "in" Where:
+      #
+      #   ['in', {:types => ALL_TYPES, :condition => 'IN', :substitutions => '(?)',
+      #    :keep_arrays => true}]
+      #
+      # <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, :condition => 'LIKE', :formatter => '"%#{param}%"'}]
+      #
+      # Be sure to single-quote the string, so that variables aren't interpolated until later. If in doubt,
+      # just use a Proc.
+      def add(*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[:condition] ||= '='
+        opts[:substitutions] ||= '?'
+        opts[:keep_arrays] ||= false
+        opts[:formatter] ||= Proc.new {|param| param}
+        if opts[:formatter].is_a?(String)
+          formatter = opts[:formatter]
+          opts[:formatter] = Proc.new {|param| eval formatter}
+        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
+      end
+      
+      # Returns the complete array of Wheres
+      def all
+        @@wheres
+      end
+      
+      # Get the where matching a method or condition.
+      def get(method_id_or_condition)
+        return nil unless where_key = @@wheres.keys.
+          sort {|a,b| b.length <=> a.length}.
+          detect {|n| method_id_or_condition.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
+    end
+  end
+  
+  Where.initialize_wheres
+end

data/lib/meta_search.rb

@@ -0,0 +1,31 @@
+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
+
+  DEFAULT_WHERES = [
+    ['equals', 'eq'],
+    ['does_not_equal', 'ne', {:types => ALL_TYPES, :condition => '!='}],
+    ['contains', 'like', {:types => STRINGS, :condition => 'LIKE', :formatter => '"%#{param}%"'}],
+    ['does_not_contain', 'nlike', {:types => STRINGS, :condition => 'NOT LIKE', :formatter => '"%#{param}%"'}],
+    ['starts_with', 'sw', {:types => STRINGS, :condition => 'LIKE', :formatter => '"#{param}%"'}],
+    ['does_not_start_with', 'dnsw', {:types => STRINGS, :condition => 'NOT LIKE', :formatter => '"%#{param}%"'}],
+    ['ends_with', 'ew', {:types => STRINGS, :condition => 'LIKE', :formatter => '"%#{param}"'}],
+    ['does_not_end_with', 'dnew', {:types => STRINGS, :condition => 'NOT LIKE', :formatter => '"%#{param}"'}],
+    ['greater_than', 'gt', {:types => (NUMBERS + DATES + TIMES), :condition => '>'}],
+    ['less_than', 'lt', {:types => (NUMBERS + DATES + TIMES), :condition => '<'}],
+    ['greater_than_or_equal_to', 'gte', {:types => (NUMBERS + DATES + TIMES), :condition => '>='}],
+    ['less_than_or_equal_to', 'lte', {:types => (NUMBERS + DATES + TIMES), :condition => '<='}],
+    ['in', {:types => ALL_TYPES, :condition => 'IN', :substitutions => '(?)', :keep_arrays => true}],
+    ['not_in', 'ni', {:types => ALL_TYPES, :condition => 'NOT IN', :substitutions => '(?)', :keep_arrays => true}]
+  ]
+  
+  RELATION_METHODS = [:joins, :includes, :all, :count, :to_sql, :paginate, :find_each, :first, :last, :each]
+end
+
+if defined?(::Rails::Railtie)
+  require 'meta_search/railtie'
+end

data/meta_search.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{meta_search}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ernie Miller"]
+  s.date = %q{2010-03-16}
+  s.description = %q{Adds a search method to your ActiveRecord models which returns an object to be used in form_for while constructing a search. Works with Rails 3 only.}
+  s.email = %q{ernie@metautonomo.us}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/meta_search.rb",
+     "lib/meta_search/builder.rb",
+     "lib/meta_search/exceptions.rb",
+     "lib/meta_search/helpers/action_view.rb",
+     "lib/meta_search/model_compatibility.rb",
+     "lib/meta_search/railtie.rb",
+     "lib/meta_search/searches/active_record.rb",
+     "lib/meta_search/searches/base.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/test_search.rb",
+     "test/test_view_helpers.rb"
+  ]
+  s.homepage = %q{http://metautonomo.us}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{ActiveRecord 3 object-based searching.}
+  s.test_files = [
+    "test/fixtures/company.rb",
+     "test/fixtures/data_type.rb",
+     "test/fixtures/developer.rb",
+     "test/fixtures/note.rb",
+     "test/fixtures/project.rb",
+     "test/fixtures/schema.rb",
+     "test/helper.rb",
+     "test/test_search.rb",
+     "test/test_view_helpers.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<activerecord>, [">= 3.0.0.beta"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 3.0.0.beta"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 3.0.0.beta"])
+  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,9 @@
+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
+  metasearch_exclude_attr :updated_at
+  metasearch_exclude_assoc :notes
+end

data/test/fixtures/data_type.rb

@@ -0,0 +1,4 @@
+class DataType < ActiveRecord::Base
+  belongs_to :company
+  metasearch_exclude_attr :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.utc(2009, 12, 24) + 86400 * n %>
+  tms       : <%= Time.utc(2009, 12, 24) + 86400 * n %>
+  tim       : <%= Time.utc(2000, 01, 01, n+8, n) %>
+  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,5 @@
+class Developer < ActiveRecord::Base
+  belongs_to :company
+  has_and_belongs_to_many :projects
+  has_many :notes, :as => :notable
+end

data/test/fixtures/developers.yml

@@ -0,0 +1,55 @@
+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

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

data/test/fixtures/projects.yml

@@ -0,0 +1,24 @@
+y2k:
+  estimated_hours: 1000
+  name           : Y2K Software Updates
+  id             : 1
+
+virus:
+  estimated_hours: 80
+  name           : Virus
+  id             : 2
+  
+awesome:
+  estimated_hours: 100
+  name           : Do something awesome
+  id             : 3
+  
+metasearch:
+  estimated_hours: 100
+  name           : MetaSearch Development
+  id             : 4
+  
+another:
+  estimated_hours: 120
+  name           : Another Project
+  id             : 5