birddog 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+test.db

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in birddog.gemspec
+gemspec
+
+group :development do 
+  gem "ruby-debug19", :require => 'ruby-debug'
+end

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.libs.push "specs"
+  t.pattern = 'specs/**/*_spec.rb'
+  t.verbose = true
+end
+
+task :spec => :test
+task :default => :spec

data/Readme.rdoc

@@ -0,0 +1,67 @@
+= Birddog
+Birddog was birthed from our experience with Bloodhound (github.com/foca/bloodhound)  Much of the code in Birddog is derived (lifted) from Bloodhound, but has been extended
+to include aggregates/regexes/testing and is Rails 3 compatible.
+
+Birddog and Bloodhound provide functionality to parse "natural language" into scopes for ActiveRecord.  They provide the avenue to enable "users" to choose the constraints 
+of a scope based on the type of the scope parameters.  (Kind of confusing, but super helpful for things like user defined rule based selection)
+
+= Using Birddog
+  Install it
+    gem install birddog       # => OR include it in your Gemfile
+
+== Example
+  Given the following model definitions
+
+    class User < ActiveRecord::Base
+      include Birddog
+
+      has_many :products
+
+      birddog do |search|
+        search.field :first_name
+        search.alias_field :name, :first_name
+        search.field :last_name
+        search.field :total_product_value, :type => :decimal, :aggregate => "SUM(products.value) AS total_product_value"
+        search.field :insensitive_last_name, :attribute => "last_name", :case_sensitive => false
+        search.field :substringed_last_name, :attribute => "last_name", :match_substring => true
+        search.field :available_product, :type => :boolean,
+                                         :attribute => "products.available",
+                                         :include => :products
+
+        search.keyword :aggregate_user do 
+          select(arel_table[:id]).
+            joins("LEFT OUTER JOIN products AS products ON (products.user_id = users.id)").
+            group(arel_table[:id])
+        end
+
+        search.text_search "first_name", "last_name", "products.name", :include => :products
+      end
+    end
+
+    class Product < ActiveRecord::Base
+      include Birddog
+
+      belongs_to :user
+
+      birddog do |search|
+        search.text_search "products.name", "products.value"
+
+        search.field :name, :regex => true, :wildcard => true
+        search.field :value, :type => :decimal
+        search.field :available, :type => :boolean
+
+        search.keyword :sort do |value|
+          { :order => "#{search.fields[value.to_sym][:attribute]} DESC" }
+        end
+      end
+    end
+
+    # The following will return all user ids with an aggregated "total_product_value" greater than 100
+    data_set = User.search("total_product_value:>100").search("aggregate_user")
+
+  You can now use birddog to query the models and run a single query chain to aggregate large datasets
+
+  There are many more aggregation and selection methods included, but this and the test suite should give you a good start.
+
+= License
+  Birddog (and subsequently Bloodhound) are licensed under MIT license (Read lib/birddog.rb for full license)

data/birddog.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "birddog/version"
+
+Gem::Specification.new do |s|
+  s.name        = "birddog"
+  s.version     = Birddog::VERSION
+  s.authors     = ["Brandon Dewitt"]
+  s.email       = ["brandonsdewitt@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Birddog (derived from Bloodhound) is for natural language scope creation and user determined rule selection}
+  s.description = %q{Seeeeeeeee Readme}
+
+  s.rubyforge_project = "birddog"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "sqlite3-ruby"
+
+  s.add_runtime_dependency "chronic"
+  s.add_runtime_dependency "activerecord"
+end

data/lib/birddog.rb

@@ -0,0 +1,180 @@
+# (The MIT License)
+# 
+# Copyright (c) 2010 Nicolas Sanguinetti, http://nicolassanguinetti.info
+# Copyright (c) 2012 Brandon Dewitt, http://abrandoned.com
+# 
+# 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.
+
+require "chronic"
+require "active_record"
+
+require "birddog/version"
+require "birddog/field_conditions"
+require "birddog/boolean_expression"
+require "birddog/date_expression"
+require "birddog/numeric_expression"
+require "birddog/searchable"
+
+module Birddog
+
+  def self.included(base)
+    base.extend(::Birddog::Searchable)
+  end
+
+  class Birddog
+    include ::Birddog::FieldConditions
+
+    attr_reader :fields
+
+    def initialize(model)
+      @model = model
+      @fields = {}
+    end
+
+    def field(name, options={}, &mapping)
+      @fields[name] = field = {
+        :attribute       => options.fetch(:attribute, name),
+        :type            => options.fetch(:type, :string),
+        :case_sensitive  => options.fetch(:case_sensitive, true),
+        :match_substring => options.fetch(:match_substring, false),
+        :regex           => options.fetch(:regex, false),
+        :wildcard        => options.fetch(:wildcard, false),
+        :aggregate       => options.fetch(:aggregate, false),
+        :options         => options.except(:attribute, :type, :case_sensitive, :match_substring, :regex, :wildcard, :aggregate),
+        :mapping         => mapping || lambda{ |v| v }
+      }
+
+      aggregate?(name) ? define_aggregate_field(name, field) : define_field(name, field)
+    end
+
+    def aggregate?(name)
+      @fields[name].fetch(:aggregate, false)
+    end
+
+    def alias_field(name, other_field)
+      @fields[name] = @fields[other_field]
+      aggregate?(name) ? define_aggregate_field(name, @fields[name]) : define_field(name, @fields[name])
+    end
+
+    def keyword(name, &block)
+      define_scope(name, &block)
+    end
+
+    def search(query)
+      tokens = tokenize(query)
+      tokens.inject(@model) do |model, (key,value)|
+        key, value = "text_search", key if value.nil?
+        scope_for(model, key, value)
+      end
+    end
+
+    def text_search(*fields)
+      options = fields.extract_options!
+      fields = fields.map { |f| "LOWER(#{f}) LIKE :value" }.join(" OR ")
+
+      define_scope "text_search" do |value|
+        options.merge(:conditions => [fields, { :value => "%#{value.downcase}%" }])
+      end
+    end
+
+    ################## PRIVATES ####################
+
+    def conditional?(value)
+      value.index(/[<>=]/) != nil   
+    end
+    private :conditional?
+
+    def define_aggregate_field(name, field)
+      field[:options].merge!(:select => field[:aggregate])
+
+      define_scope(name) do |value|
+        if conditional?(value)
+          field[:options].merge(:having => setup_conditions(field, value))
+        else
+          field[:options]
+        end
+      end
+    end
+    private :define_aggregate_field
+
+    def define_field(name, field)
+      define_scope(name) do |value|
+        field[:options].merge(:conditions => setup_conditions(field, value))
+      end
+    end
+    private :define_field
+
+    def scope_name_for(key)
+      "_birddog_scope_#{key}"
+    end
+    private :scope_name_for
+
+    def define_scope(name, &scope)
+      @model.send(:scope, scope_name_for(name), scope)
+    end
+    private :define_scope
+
+    def cast_value(value, type)
+      case type
+      when :boolean then
+        BooleanExpression.parse(value)
+      when :float, :decimal, :integer then
+        NumericExpression.new(value, type)
+      when :date then
+        DateExpression.new(value)
+      when :time, :datetime then
+        Chronic.parse(value)
+      else
+        value.strip
+      end
+    end
+    private :cast_value
+
+    def setup_conditions(field, value)
+      value = cast_value(value, field[:type])
+      value = field[:mapping].call(value)
+
+      case field[:type]
+      when :string then
+        conditions_for_string_search(field, value)
+      when :float, :decimal, :integer then
+        conditions_for_numeric(field, value)
+      when :date, :datetime, :time then 
+        conditions_for_date(field, value)
+      else
+        { field[:attribute] => value }
+      end
+    end
+    private :setup_conditions
+
+    def tokenize(query)
+      split_tokens = query.split(":")
+      split_tokens.each { |tok| tok.strip! }
+
+      [[split_tokens.shift, split_tokens.join(":")]]
+    end
+    private :tokenize
+
+    def scope_for(model, key, value)
+      scope_name = scope_name_for(key)
+
+      if model.respond_to?(scope_name)
+        model.send(scope_name, value)
+      else
+        model.scoped
+      end
+    end
+    private :scope_for
+
+  end
+
+end

data/lib/birddog/boolean_expression.rb

@@ -0,0 +1,16 @@
+module Birddog
+
+  class BooleanExpression
+
+    def self.parse(value)
+      { "true"  => true,
+        "yes"   => true,
+        "y"     => true,
+        "false" => false,
+        "no"    => false,
+        "n"     => false }.fetch("#{value.downcase}", true)
+    end
+
+  end
+
+end

data/lib/birddog/date_expression.rb

@@ -0,0 +1,24 @@
+module Birddog
+
+  class DateExpression
+    attr_reader :value, :condition
+
+    def initialize(value)
+      # allow additional spaces to be entered between conditions and value
+      value.gsub!(/\s/, '')
+      parts = value.scan(/(?:[=<>]+|(?:[0-9]{1,2}\/[0-9]{1,2}\/[0-9]{4}))/)[0,2]
+      @value = Date.parse(Chronic.parse(parts.last).to_s)
+      @condition = sanitize_condition(parts.first)
+    end
+
+    def sanitize_condition(cond)
+      valid = %w(= == > < <= >= <>)
+      valid.include?(cond) ? cond.strip : "="
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+
+end

data/lib/birddog/field_conditions.rb

@@ -0,0 +1,50 @@
+module Birddog
+
+  module FieldConditions
+
+    def conditions_for_string_search(field, value)
+      search_con = " LIKE ? "
+      field_to_search = "lower(#{field[:attribute]})"
+      value_to_search = value.downcase
+
+      if field[:case_sensitive]
+        field_to_search = field[:attribute]
+        value_to_search = value
+      end
+
+      if field[:match_substring]
+        value_to_search = "%#{value_to_search}%"
+      end
+
+      if field[:regex] && regexed?(value)
+        # TODO check db driver to determine regex operator for DB (current is Postgres)
+        search_con = " ~ ? "
+        value_to_search = value[1..value.size-2]
+        field_to_search = field[:attribute]
+      elsif field[:wildcard] && value_to_search.include?("*")
+        value_to_search.gsub!(/[\*]/, "%")
+      end
+
+      [ "#{field_to_search} #{search_con} ", value_to_search ]
+    end
+
+    def conditions_for_date(field, value)
+      [ "#{field[:attribute]} #{value.condition} ? ", value.value.strftime("%Y-%m-%d")]
+    end
+
+    def conditions_for_numeric(field, value)
+      case value.condition
+      when "=" then
+        [ "ABS(#{field[:attribute]}) >= ? AND ABS(#{field[:attribute]}) < ?", value.to_f.abs.floor, (value.to_f.abs + 1).floor ]
+      else
+        [ "#{field[:attribute]} #{value.condition} ? ", value.to_f ]
+      end
+    end
+
+    def regexed?(value)
+      (value[0].chr == '/' && value[-1].chr == '/')
+    end
+
+  end
+
+end

data/lib/birddog/numeric_expression.rb

@@ -0,0 +1,35 @@
+module Birddog
+
+  class NumericExpression
+
+    attr_reader :condition
+
+    def initialize(value, type)
+      # allow additional spaces to be entered between conditions and value
+      value.gsub!(/\s/, '')
+      parts = value.scan(/(?:[=<>]+|(?:-?\d|\.)+)/)[0,2]
+
+      @value = Float(parts.last)
+      @value = @value.to_i if type == :integer
+      @condition = sanitize_condition(parts.first)
+    end
+
+    def sanitize_condition(cond)
+      valid = %w(= == > < <= >= <>)
+      valid.include?(cond) ? cond.strip : "="
+    end
+
+    def to_i
+      @value.to_i
+    end
+
+    def to_f
+      @value.to_f
+    end
+
+    def to_s
+      @value.to_s
+    end
+  end
+
+end

data/lib/birddog/searchable.rb

@@ -0,0 +1,16 @@
+module Birddog
+
+  module Searchable
+
+    def birddog(&block)
+      @birddog ||= ::Birddog::Birddog.new(self)
+      block ? @birddog.tap(&block) : @birddog
+    end
+
+    def scopes_for_query(query)
+      birddog.search(query)
+    end
+
+  end
+
+end

data/lib/birddog/version.rb

@@ -0,0 +1,3 @@
+module Birddog
+  VERSION = "0.0.1"
+end

data/specs/birddog_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+describe Birddog::Birddog do ####################
+  before :each do
+    User.destroy_all
+    Product.destroy_all
+    @john = User.create(:first_name => "John", :last_name => "Doe")
+    @ducky = @john.products.create(:name => "Rubber Duck", :value => 10)
+    @tv = @john.products.create(:name => "TV", :value => 200)
+  end
+
+  it "finds a user by first_name" do
+    User.scopes_for_query("first_name:John").must_include(@john)
+  end
+
+  it "finds a user by first_name, using an alias" do
+    User.scopes_for_query("name:John").must_include(@john)
+  end
+
+  it "finds by text search" do
+    Product.scopes_for_query("duck rubber").must_include(@ducky)
+  end
+
+  #  TODO figure out the cross platform way
+  #  it "finds by regex search" do 
+  #    Product.scopes_for_query("name : /TV/").must_include(@tv)
+  #  end
+
+  it "finds by wildcard character" do 
+    Product.scopes_for_query("name : T*").must_include(@tv)
+  end
+
+  it "finds a user by last_name, but only in a case sensitive manner" do
+    User.scopes_for_query("last_name:Doe").must_include(@john)
+    User.scopes_for_query("last_name:Doe").size.must_equal(1)
+  end
+
+  it "can find using case insensitive search" do
+    User.scopes_for_query("insensitive_last_name:doe").must_include(@john)
+    User.scopes_for_query("insensitive_last_name:doe").size.must_equal(1)
+  end
+
+  it "can find matching substrings" do
+    User.scopes_for_query("substringed_last_name:oe").must_include(@john)
+    User.scopes_for_query("substringed_last_name:oe").size.must_equal(1)
+  end
+
+  it "can find using key:value pairs for attributes that define a type" do
+    User.scopes_for_query("available_product:yes").must_include(@john)
+    User.scopes_for_query("available_product:no").wont_include(@john)
+  end
+
+  it "allows defining arbitrary keywords to create scopes" do
+    @john.products.scopes_for_query("sort:name").all.must_equal([@tv, @ducky])
+  end
+
+  describe "numeric fields" do ########################
+    it "searches by equals" do
+      @john.products.scopes_for_query("value:=10").must_include(@ducky)
+      @john.products.scopes_for_query("value:=10").size.must_equal(1)
+    end
+
+    it "searches by equality without =" do 
+      @john.products.scopes_for_query("value:10").must_include(@ducky)
+      @john.products.scopes_for_query("value:10").size.must_equal(1)
+    end
+
+    it "searches by greater than" do 
+      @john.products.scopes_for_query("value:>100").must_include(@tv)
+      @john.products.scopes_for_query("value:>100").size.must_equal(1)
+    end
+
+    it "searches by less than" do 
+      @john.products.scopes_for_query("value:<100").must_include(@ducky)
+      @john.products.scopes_for_query("value:<100").size.must_equal(1)
+    end
+
+    it "searches by =>" do
+      @john.products.scopes_for_query("value:>=200").must_include(@tv)
+      @john.products.scopes_for_query("value:>=200").size.must_equal(1)
+    end
+
+    it "searches on negatives" do 
+      @john.products.scopes_for_query("value:>=-200").must_include(@tv)
+      @john.products.scopes_for_query("value:>=-200").must_include(@ducky)
+      @john.products.scopes_for_query("value:>=-200").size.must_equal(2)
+    end
+
+    describe "spacing" do ###########################
+      specify { @john.products.scopes_for_query("value : >= 200").must_include(@tv) }
+      specify { @john.products.scopes_for_query("value : >=200").must_include(@tv) }
+      specify { @john.products.scopes_for_query("value: >= 200 ").must_include(@tv) }
+      specify { @john.products.scopes_for_query("value :>= 200").must_include(@tv) }
+      specify { @john.products.scopes_for_query("value:>= 200").must_include(@tv) }
+      specify { @john.products.scopes_for_query(" value:>= 200").must_include(@tv) }
+      specify { @john.products.scopes_for_query("value: >=200").must_include(@tv) }
+    end
+
+  end
+  
+end

data/specs/complex_scope_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Birddog::Birddog do
+  before :each do
+    User.destroy_all
+    Product.destroy_all
+    @john = User.create(:first_name => "John", :last_name => "Doe")
+    @ducky = @john.products.create(:name => "Rubber Duck", :value => 10)
+    @tv = @john.products.create(:name => "TV", :value => 200)
+    @bike = @john.products.create(:name => "Bike", :value => 100)
+  end
+
+  describe "aggregates" do 
+    it "doesn't include HAVING clause when no condition included" do 
+      sql = User.scopes_for_query("aggregate_user").scopes_for_query("total_product_value").to_sql
+      sql.wont_match(/HAVING/i)
+    end
+
+    it "includes HAVING clause when condition included" do 
+      sql = User.scopes_for_query("aggregate_user").scopes_for_query("total_product_value:>0").to_sql
+      sql.must_match(/HAVING/i)
+    end
+
+    it "calculates sums" do 
+      sum = User.scopes_for_query("aggregate_user").
+        scopes_for_query("total_product_value:>0")
+
+      db_sum = User.first.products.inject(0.0) {|a,n| a + n.value }
+      sum.first.total_product_value.must_equal(db_sum)
+    end
+  end
+
+  describe "chained scopes" do 
+    it "chains numeric" do 
+      products = Product.scopes_for_query("value: > 11").
+        scopes_for_query("value: < 101")
+
+      products.size.must_equal(1)
+      products.must_include(@bike)
+    end
+
+    it "chains numeric/wildcard" do 
+      products = Product.scopes_for_query("value: > 11").
+        scopes_for_query("value: < 300").
+        scopes_for_query("name: T*")
+
+      products.size.must_equal(1)
+      products.must_include(@tv)
+    end
+  end
+
+end

data/specs/field_conditions_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe ::Birddog::FieldConditions do ##############
+  class RegexTestClass
+    extend ::Birddog::FieldConditions
+  end
+
+  ["/regex/",
+    "/man on a buffalo//",
+    " /straight up mauled/",
+    "/by a cougar/ ",
+    " /buffalo/ "].each do |reg|
+    it "identifies #{reg} as regex" do 
+      RegexTestClass.regexed?(reg.strip).must_equal(true)
+    end
+  end
+
+  ["regex/",
+    "/man on a buffalo",
+    " /straight up mauled/ and stuff"].each do |reg|
+    it "doesnt identify #{reg} as regex" do 
+      RegexTestClass.regexed?(reg.strip).must_equal(false)
+    end
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :development, :test)
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'support/minitest_matchers'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => "specs/test.db"
+)
+
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table(table)
+end
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :users do |t|
+    t.string :first_name
+    t.string :last_name
+  end
+
+  create_table :products do |t|
+    t.string :name
+    t.integer :value
+    t.boolean :available, :default => true
+    t.belongs_to :user
+  end
+end
+
+class User < ActiveRecord::Base
+  include Birddog
+
+  has_many :products
+
+  birddog do |search|
+    search.field :first_name
+    search.alias_field :name, :first_name
+    search.field :last_name
+    search.field :total_product_value, :type => :decimal, :aggregate => "SUM(products.value) AS total_product_value"
+    search.field :insensitive_last_name, :attribute => "last_name", :case_sensitive => false
+    search.field :substringed_last_name, :attribute => "last_name", :match_substring => true
+    search.field :available_product, :type => :boolean,
+                                     :attribute => "products.available",
+                                     :include => :products
+
+    search.keyword :aggregate_user do 
+      select(arel_table[:id]).
+        joins("LEFT OUTER JOIN products AS products ON (products.user_id = users.id)").
+        group(arel_table[:id])
+    end
+
+    search.text_search "first_name", "last_name", "products.name", :include => :products
+  end
+end
+
+class Product < ActiveRecord::Base
+  include Birddog
+
+  belongs_to :user
+
+  birddog do |search|
+    search.text_search "products.name", "products.value"
+
+    search.field :name, :regex => true, :wildcard => true
+    search.field :value, :type => :decimal
+    search.field :available, :type => :boolean
+
+    search.keyword :sort do |value|
+      { :order => "#{search.fields[value.to_sym][:attribute]} DESC" }
+    end
+  end
+end

data/specs/support/minitest_matchers.rb

@@ -0,0 +1,5 @@
+require 'minitest/spec'
+
+module MiniTest::Expectations
+  infect_an_assertion :assert_equal, :must_be
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: birddog
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brandon Dewitt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-31 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &12927140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12927140
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &12926220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12926220
+- !ruby/object:Gem::Dependency
+  name: sqlite3-ruby
+  requirement: &12867540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12867540
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: &12866680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *12866680
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &12866120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *12866120
+description: Seeeeeeeee Readme
+email:
+- brandonsdewitt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- Readme.rdoc
+- birddog.gemspec
+- lib/birddog.rb
+- lib/birddog/boolean_expression.rb
+- lib/birddog/date_expression.rb
+- lib/birddog/field_conditions.rb
+- lib/birddog/numeric_expression.rb
+- lib/birddog/searchable.rb
+- lib/birddog/version.rb
+- specs/birddog_spec.rb
+- specs/complex_scope_spec.rb
+- specs/field_conditions_spec.rb
+- specs/spec_helper.rb
+- specs/support/minitest_matchers.rb
+- specs/test.db
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: birddog
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Birddog (derived from Bloodhound) is for natural language scope creation
+  and user determined rule selection
+test_files: []
+has_rdoc: