queryable_with 0.1.0

data/CHANGELOG

@@ -0,0 +1,5 @@
+= QueryableWith Changelog
+
+== 0.1.0
+
+ * First release. Supports query_set, queryable_with, and default_scope.

data/README.rdoc

@@ -0,0 +1,88 @@
+= QueryableWith
+
+QueryableWith is an ActiveRecord library for creating and combining reusable sets of scopes. Instead of building up
+your query using if-conditions checking for the existence of certain parameters--a common use case in reporting and
+controller query logic--QueryableWith combines them together, and only uses the ones the params you pass need.
+
+For example,
+
+  class User < ActiveRecord::Base
+    named_scope :born_after, lambda {|date|
+      { :conditions => ["birthdate >= ?", date] }
+    }
+
+   named_scope :active, :conditions => { :active => true }
+
+    query_set :filter do
+      add_scope :active
+      queryable_with :email
+      queryable_with(:born_after) { |d| Date.parse(d) }
+    end
+  end
+
+will add a method, <tt>User.filter</tt>, that knows how to filter on the <tt>email</tt> and <tt>born_after</tt>
+parameters by, respectively, performing an equality search against that column, and using the defined name
+scope (after passing the given date value, in this case a string, through the block). It will always add the
+<tt>active</tt> scope. For example,
+
+  User.filter
+  #=> User.active
+
+  User.filter(:email => "gthreepwood@melee.gov") 
+  #=> User.active.scoped(:conditions => { :email => "gthreepwood@melee.gov"})
+
+  User.filter(:born_after => "10/4/2010")
+  #=> User.active.born_after(#<Date: 4910947/2,0,2299161>)
+
+See QueryableWith::ClassMethods#query_set for more information.
+
+== Another Example
+
+  class User < ActiveRecord::Base
+    query_set :search do
+      # If queried by :name, execute a LIKE query on both the :first_name and :last_name columns.
+      # User.scoped(:conditions => ["(users.first_name LIKE ?) OR (users.last_name LIKE ?)", ...])
+      queryable_with :name, :columns => [ :first_name, :last_name ], :wildcard => true
+      
+      # If queried by :username, execute a LIKE query on the the email column.
+      # User.scoped(:conditions => ["(users.email LIKE ?)", ...])      
+      queryable_with :username, :column => :email, :wildcard => true
+    end
+  end
+
+  User.search(:name => ["Guy", "Three"])
+  #=> User.scoped(:conditions => ["(users.first_name LIKE ?) OR (users.last_name LIKE ?) OR ...", "%Guy%", "%Three%", "%Guy%", "%Three%"]
+
+  User.search(:username => "gthree")
+  #=> User.scoped(:conditions => { :email => "%gthree%"})
+
+== Installation and usage
+
+QueryableWith is available as a gem. It has a dependency on ActiveRecord, which it will automatically extend with
+the necessary class methods when required. It is not yet compatible with Rails3.
+
+  gem install queryable_with
+  require 'queryable_with'
+
+== License
+
+Copyright (c) 2010 Brian Guthrie
+
+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/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/rdoctask'
+
+require 'spec'
+require 'spec/rake/spectask'
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "queryable_with/version"
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--colour', '--format progress', '--backtrace']
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end
+
+namespace :gem do
+  task :clean do
+    system "rm -f *.gem"
+  end
+  
+  task :build => :clean do
+    system "gem build queryable_with.gemspec"
+  end
+  
+  task :release => :build do
+    system "gem push queryable_with-#{QueryableWith::Version::STRING}"
+  end
+end

data/lib/queryable_with.rb

@@ -0,0 +1,194 @@
+require 'active_record'
+
+# See README.rdoc for an extended introduction. The QueryableWith::ClassMethods#query_set, 
+# QueryableWith::QuerySet#queryable_with and QueryableWith::QuerySet#add_scope methods may also
+# be of interest.
+module QueryableWith
+
+  def self.included(active_record) # :nodoc:
+    active_record.send :extend, QueryableWith::ClassMethods
+  end
+  
+  module ClassMethods
+    def query_sets # :nodoc:
+      read_inheritable_attribute(:query_sets) || write_inheritable_hash(:query_sets, {})
+    end
+    
+    # Defines a query set with the given name. This has the effect of defining a method that calls
+    # every implicit or explicit scope added to that query set.
+    #
+    # When a block is given, that block is evaluated in the context of either a newly-created query
+    # set or (in the case of inherited classes) the pre-existing set of that name. See 
+    # QueryableWith::QuerySet#queryable_with and QueryableWith::QuerySet#add_scope for more details.
+    #
+    # When <tt>parent</tt> is given as an option, the new query set will inherit all of the scopes from
+    # the named parent.
+    def query_set(set_name, options={}, &block) # :yields:
+      set = query_set_for(set_name, options).tap { |s| s.instance_eval(&block) if block_given? }
+      
+      class_eval <<-RUBY
+        def self.#{set_name}(params={})
+          self.query_sets["#{set_name}"].query(self, params)
+        end
+      RUBY
+    end
+    
+    protected
+    
+      def query_set_for(set_name, options) # :nodoc:
+        query_sets[set_name.to_s] || query_sets.store(set_name.to_s, QueryableWith::QuerySet.new(options))
+      end
+  end
+  
+  class QuerySet
+    
+    def initialize(options={}) # :nodoc:
+      @queryables = []
+      
+      if options.has_key?(:parent)
+        @queryables << QueryableWith::ImplicitScopeParameter.new(options[:parent])
+      end
+    end
+    
+    # Make this QuerySet queryable with the named parameter(s). If no other options are given,
+    # this will result in a query on either the column or (if defined) scope of the same
+    # name of the base scope and values passed to #query. It also accepts the following options:
+    #
+    # * <tt>scope</tt> - Map the incoming parameter to this scope. The argument by be a symbol (name of the 
+    #   scope), a Hash (scope conditions) or a lambda.
+    # * <tt>column</tt> - Map the incoming parameter to this column.
+    # * <tt>default</tt> - Default the incoming parameter to this value even if it isn't provided.
+    # * <tt>wildcard</tt> - If true, generate a SQL LIKE query with the incoming parameter. Used only 
+    #   if the <tt>scope</tt> option is absent or a block is not provided.
+    # * <tt>allow_blank</tt> - If true, treat incoming parameters mapped to nil or a blank string as
+    #   IS NULL for the purposes of SQL query generation. Used only if the <tt>scope</tt> option is absent.
+    #
+    # If a block is provided, incoming parameters to the query will be passed through that function first. 
+    # For example,
+    #
+    #   queryable_with(:company_name, :scope => :by_company) do |name| 
+    #     Company.find_by_name(name)
+    #   end
+    #
+    # will attempt to look up a company name first, then pass it to a pre-defined scope called 
+    # <tt>by_company</tt>.
+    def queryable_with(*expected_parameters, &block)
+      options = expected_parameters.extract_options!
+      
+      @queryables += expected_parameters.map do |parameter|
+        QueryableWith::QueryableParameter.new(parameter, options, &block)
+      end
+    end
+    
+    # Add a scope that is always applied to any calls to #query. This may be a symbol (the name of
+    # the scope to add), a Hash (scope conditions) or a lambda. Useful when, for example, you only
+    # ever want to see records with an <tt>active</tt> flag set to true.
+    #
+    #   add_scope :active
+    #   add_scope :conditions => { :active => true }
+    def add_scope(scope)
+      @queryables << QueryableWith::ImplicitScopeParameter.new(scope)
+    end
+    
+    # Applies all of the defined queryable and added scopes in this query set to the given base scope
+    # (usually an ActiveRecord class, but can also be a pre-existing NamedScope object) based on the
+    # query parameters and returns a new scope, ready to be queried.
+    def query(base_scope, params={}) # :nodoc:
+      @queryables.inject(base_scope) do |scope, queryer|
+        queryer.query(scope, params)
+      end.scoped({})
+    end
+    
+  end
+  
+  class ImplicitScopeParameter # :nodoc:
+    
+    def initialize(scope)
+      @scope = scope
+    end
+    
+    def query(queryer, params={})
+      if @scope.is_a? Symbol
+        queryer.send @scope, params
+      else
+        queryer.scoped @scope
+      end
+    end
+    
+  end
+  
+  class QueryableParameter # :nodoc:
+    attr_reader :expected_parameter, :column_name
+    
+    def initialize(expected_parameter, options={}, &block)
+      @scope, @wildcard, @default_value, @allow_blank = options.values_at(:scope, :wildcard, :default, :allow_blank)
+      @expected_parameter = expected_parameter.to_sym
+      @column_name = options[:column] || @expected_parameter.to_s
+      @value_mapper = block || lambda {|o| o}
+    end
+    
+    def scoped?; !@scope.blank?; end
+    def wildcard?; @wildcard == true; end
+    def blank_allowed?; @allow_blank == true; end
+    def has_default?; !@default_value.nil?; end
+    def scope_name; @scope || self.expected_parameter; end
+    
+    def query(queryer, params={})
+      params = params.with_indifferent_access
+      params_contain_queryable_value, queried_value = determine_queried_value(params[@expected_parameter])
+      
+      return queryer unless params_contain_queryable_value
+      queried_value = @value_mapper.call(queried_value)
+      
+      if scoped? || queryer_scoped?(queryer)
+        queryer.send scope_name, queried_value
+      else
+        queryer.scoped(:conditions => conditions_for(queryer, queried_value))
+      end
+    end
+    
+    protected
+    
+      def determine_queried_value(value_in_params)
+        if value_in_params.blank? && value_in_params != false
+          if blank_allowed?
+            return true, nil
+          elsif has_default?
+            return true, @default_value
+          else
+            return false, nil
+          end
+        else
+          return true, value_in_params
+        end
+      end
+    
+      def queryer_scoped?(queryer)
+        queryer.scopes.keys.include?(@expected_parameter)
+      end
+      
+      def conditions_for(queryer, value)
+        query_string = if wildcard?
+          "(#{queryer.table_name}.#{self.column_name} LIKE ?)"
+        else
+          "(#{queryer.table_name}.#{self.column_name} = ?)"
+        end
+        
+        final_values = [ value ].flatten.map do |value|
+          wildcard? ? "%#{value}%" : value
+        end
+        
+        final_query_string = ( [ query_string ] * final_values.size ).join(" OR ")
+        
+        [ final_query_string ] + final_values
+      end
+    
+  end
+  
+end
+
+module ActiveRecord # :nodoc:
+  class Base # :nodoc:
+    include QueryableWith
+  end
+end

data/lib/queryable_with/version.rb

@@ -0,0 +1,9 @@
+module QueryableWith #:nodoc:
+  module Version #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/spec/queryable_with_spec.rb

@@ -0,0 +1,239 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe QueryableWith do
+  before :each do
+    User.delete_all
+    User.query_sets.clear
+  end
+  
+  it "includes itself in ActiveRecord" do
+    ActiveRecord::Base.ancestors.should include(QueryableWith)
+  end
+  
+  describe "query_set" do
+    it "exposes a new method named after the defined query set" do
+      User.query_set :test
+      User.methods.should include("test")
+    end
+    
+    it "returns a scope that points to an empty result set if the query set is empty" do
+      User.query_set :test
+      User.test.should == [ ]
+    end
+    
+    describe ":parent => [query_set_name]" do
+      it "applies a parent set that adds a scope" do
+        User.query_set(:test)                        { add_scope(:conditions => { :active => true }) }
+        User.query_set(:supertest, :parent => :test) { add_scope(:conditions => { :name => "Guybrush" }) }
+
+        active_guy   = User.create! :name => "Guybrush", :active => true
+        inactive_guy = User.create! :name => "Guybrush", :active => false
+
+        User.supertest.should == [ active_guy ]
+      end
+
+      it "applies a parent set that is itself queryable" do
+        User.query_set(:test)                        { queryable_with(:name) }
+        User.query_set(:supertest, :parent => :test) { add_scope(:conditions => { :active => true }) }
+
+        active_guy   = User.create! :name => "Guybrush", :active => true
+        inactive_guy = User.create! :name => "Guybrush", :active => false
+        active_gal   = User.create! :name => "Elaine",   :active => true
+
+        User.supertest(:name => "Guybrush").should == [ active_guy ]
+      end
+    end
+  end
+  
+  describe "queryable_with" do
+    it "maps a parameter directly to a column" do
+      guybrush = User.create! :name => "Guybrush"
+      elaine   = User.create! :name => "Elaine"
+      User.query_set(:test) { queryable_with(:name) }
+      
+      User.test(:name => "Guybrush").should == [ guybrush ]
+    end
+    
+    it "maps multiple parameters, each to their own column" do
+      guybrush = User.create! :name => "Guybrush", :active => true
+      elaine   = User.create! :name => "Elaine", :active => false
+      User.query_set(:test) { queryable_with(:name, :active) }
+      
+      # User.test(:name => "Guybrush").should == [ guybrush ]
+      User.test(:active => false).should == [ elaine ]
+    end
+    
+    it "uses the correct table name when referring to columns with potentially conflicting names" do
+      # The employers table also has a name column.
+      User.query_set(:test) { queryable_with(:name) }
+      
+      lambda do
+        User.test(:name => "Guybrush").all(:joins => :employer)
+      end.should_not raise_error(ActiveRecord::StatementInvalid)
+    end
+    
+    it "selects any one of a given list of values" do
+      guybrush = User.create! :name => "Guybrush"
+      elaine   = User.create! :name => "Elaine"
+      User.query_set(:test) { queryable_with(:name) }
+      
+      User.test(:name => ["Guybrush", "Elaine"]).should include(guybrush, elaine)
+    end
+    
+    it "returns a scope that points to an empty result set if queried with an empty set of params" do
+      User.query_set(:test) { queryable_with(:name) }
+      User.test.should == [ ]
+    end
+    
+    it "applies multiple parameters if multiple parameters are queried" do
+      active_bob = User.create! :name => "Bob", :active => true
+      lazy_bob   = User.create! :name => "Bob", :active => false
+      User.query_set(:test) { queryable_with(:name, :active) }
+      
+      User.test(:name => "Bob", :active => true).should == [ active_bob ]
+    end
+    
+    it "delegates the underlying filter to a pre-existing named scope if one of that name is defined" do
+      guybrush = User.create! :name => "Guybrush"
+      User.named_scope(:naym, lambda { |name| { :conditions => { :name => name } } })
+      User.query_set(:test) { queryable_with(:naym) }
+      
+      User.test(:naym => "Guybrush").should == [ guybrush ]
+      User.test(:naym => "Herrman").should == [ ]
+    end
+    
+    it "ignores blank values" do
+      guybrush = User.create! :name => "Guybrush"
+      User.query_set(:test) { queryable_with(:name) }
+      User.test(:name => "").should == [ guybrush ]
+      User.test(:name => nil).should == [ guybrush ]
+    end
+    
+    describe ":scope => [scope_name]" do
+      it "delegates the underlying filter to a pre-existing scope if passed as an option" do
+        guybrush = User.create! :name => "Guybrush"
+        User.named_scope(:naym, lambda { |name| { :conditions => { :name => name } } })
+        User.query_set(:test) { queryable_with(:nizame, :scope => :naym) }
+      
+        User.test(:nizame => "Guybrush").should == [ guybrush ]
+        User.test(:nizame => "Herrman").should == [ ]
+      end
+    end
+    
+    describe ":wildcard => true" do
+      it "wildcards the given value" do
+        guybrush = User.create! :name => "Guybrush"
+        User.query_set(:test) { queryable_with(:name, :wildcard => true) }
+        
+        User.test(:name => "uybru").should == [ guybrush ]
+        User.test(:name => "Elaine").should == [ ]
+      end
+      
+      it "ORs multiple wildcarded values" do
+        guybrush = User.create! :name => "Guybrush"
+        elaine   = User.create! :name => "Elaine"
+        User.query_set(:test) { queryable_with(:name, :wildcard => true) }
+        
+        User.test(:name => ["uybru", "lain"]).should include(guybrush, elaine)
+      end
+    end
+    
+    describe ":column => [column_name]" do
+      it "maps the parameter to the given column name" do
+        guybrush = User.create! :name => "Guybrush"
+        elaine   = User.create! :name => "Elaine"
+        User.query_set(:test) { queryable_with(:naym, :column => :name) }
+
+        User.test(:naym => "Guybrush").should == [ guybrush ]
+      end
+    end
+    
+    describe ":default => [value]" do
+      it "provides a default value if none is given in the query" do
+        guybrush = User.create! :name => "Guybrush"
+        elaine   = User.create! :name => "Elaine"
+        User.query_set(:test) { queryable_with(:name, :default => "Guybrush") }
+        
+        User.test.should == [ guybrush ]
+      end
+    end
+    
+    describe ":allow_blank => [boolean]" do
+      it "accepts, and queries on, blank values" do
+        guybrush = User.create! :name => "Guybrush"
+        User.query_set(:test) { queryable_with(:name, :allow_blank => true) }
+        User.test(:name => "").should == [ ]
+        User.test(:name => nil).should == [ ]
+      end
+    end
+    
+    describe "with a block" do
+      it "permits you to transform the incoming value with a standard column lookup" do
+        guybrush = User.create! :name => "Guybrush"
+        elaine   = User.create! :name => "Elaine"
+        User.query_set(:test) { queryable_with(:name) { |str| str.gsub(/fawkes/, "brush") } }
+        
+        User.test(:name => "Guyfawkes").should == [ guybrush ]
+      end
+      
+      it "permits you to transform the incoming value with a scope" do
+        guybrush1 = User.create! :name => "Guybrush", :employer => Employer.create!(:name => "Threepwood Nautical Services LLC")
+        guybrush2 = User.create! :name => "Guybrush", :employer => Employer.create!(:name => "LeChuck LeLumber, Inc.")
+        
+        User.named_scope :by_employer, lambda { |employer| 
+          { :conditions => { :employer_id => employer } } 
+        }
+        
+        User.query_set(:test) do
+          queryable_with :employer_name, :scope => :by_employer do |name|
+            Employer.find_by_name(name)
+          end
+        end
+        
+        User.test(:employer_name => "Threepwood Nautical Services LLC").should == [ guybrush1 ]
+      end
+    end
+  end
+  
+  describe "add_scope" do
+    it "adds the given named scope to every query" do
+      active   = User.create! :active => true
+      inactive = User.create! :active => false
+      User.named_scope(:only_active, :conditions => { :active => true })
+      User.query_set(:test) { add_scope(:only_active) }
+
+      User.test.all.should == [ active ]
+    end
+    
+    it "adds the given ad hoc scope to every query" do
+      active   = User.create! :active => true
+      inactive = User.create! :active => false
+      User.query_set(:test) { add_scope(:conditions => { :active => true }) }
+      
+      User.test.all.should == [ active ]
+    end
+  end
+  
+  describe "(subclassed)" do
+    it "inherits the query sets from its superclass" do
+      User.query_set(:test) { add_scope(:conditions => { :active => true }) }
+      class Pirate < User; end
+      active   = Pirate.create! :active => true
+      inactive = Pirate.create! :active => false
+      
+      Pirate.test.should == [ active ]
+    end
+    
+    it "allows query sets to be extended by the subclass" do
+      User.query_set(:test) { add_scope(:conditions => { :active => true }) }
+      class Pirate < User; end
+      Pirate.query_set(:test) { add_scope(:conditions => { :name => "Guybrush" }) }
+      
+      active_guy   = Pirate.create! :name => "Guybrush", :active => true
+      inactive_guy = Pirate.create! :name => "Guybrush", :active => false
+      
+      Pirate.test.should == [ active_guy ]
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'spec'
+require 'queryable_with'
+
+LOGFILE = File.open(File.dirname(__FILE__) + '/../tmp/database.log', 'a')
+ActiveRecord::Base.logger = Logger.new(LOGFILE)
+ActiveRecord::Base.configurations = true
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :users do |t|
+    t.string   "name"
+    t.date     "birthdate"
+    t.string   "email"
+    t.string   "join_date"
+    t.integer  "income"
+    t.integer  "employer_id"
+    t.string   "type"
+    t.boolean  "active"
+  end
+  
+  create_table :employers do |t|
+    t.string "name"
+    t.string "email"
+    t.timestamps
+  end
+end
+
+class User < ActiveRecord::Base
+  belongs_to :employer
+end
+
+class Employer < ActiveRecord::Base
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: queryable_with
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Brian Guthrie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-16 00:00:00 +05:30
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Tie query parameters to scopes, or create dynamic scopes on the fly. Define sets of reusable scopes for use in reporting and filtering.
+email: 
+- btguthrie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/queryable_with/version.rb
+- lib/queryable_with.rb
+- README.rdoc
+- CHANGELOG
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/bguthrie/queryable_with
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: An ActiveRecord library for creating reusable sets of scopes.
+test_files: 
+- spec/queryable_with_spec.rb
+- spec/spec_helper.rb