paraphrase 0.2.0

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,5 @@
+Gemfile.lock
+doc/
+pkg/
+vendor/cache/*.gem
+.yardoc

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "paraphrase Documentation" --protected -M github-markup -M redcarpet

data/Appraisals

@@ -0,0 +1,17 @@
+appraise '3.0' do
+  gem 'activerecord', '3.0.15'
+  gem 'activemodel', '3.0.15'
+  gem 'activesupport', '3.0.15'
+end
+
+appraise '3.1' do
+  gem 'activerecord', '3.1.6'
+  gem 'activemodel', '3.1.6'
+  gem 'activesupport', '3.1.6'
+end
+
+appraise '3.2' do
+  gem 'activerecord', '3.2.6'
+  gem 'activemodel', '3.2.6'
+  gem 'activesupport', '3.2.6'
+end

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2012-06-04
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Eduardo Gutierrez
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,134 @@
+# paraphrase
+
+paraphrase provides a way to map one or multiple request params to model
+scopes.
+
+paraphrase was designed and geared towards building a query-based public API
+where you may want to require certain parameters to prevent consumers from
+scraping all your information or to mitigate the possibility of large,
+performance-intensive data-dumps.
+
+## Installation
+
+Via a gemfile:
+
+```ruby
+gem 'paraphrase'
+```
+
+```
+$ bundle
+```
+
+Or manually:
+
+```
+$ gem install paraphrase
+```
+
+## Usage
+
+paraphrase aims to be as flexible as possible for your needs.
+* From within an `ActiveRecord::Base` subclass:
+
+```ruby
+class Post < ActiveRecord::Base
+  register_mapping do
+    scope :by_user, :key => :author
+  end
+
+  def self.by_user(author_name)
+    joins(:user).where(:user => { :name => author_name })
+  end
+end
+```
+
+* In an initializer to register multiple mappings in one place:
+
+```ruby
+# config/initializers/paraphrase.rb
+
+Paraphrase.configure do |mappings|
+  mappings.register :post do
+    paraphrases Post
+    scope :by_user, :key => :author
+  end
+end
+```
+
+* By creating a subclass of `Paraphrase::Query`:
+
+```ruby
+class PostQuery < Paraphrase::Query
+  paraphrases Post
+
+  scope :by_user, :key => :author
+end
+```
+
+Then in a controller you can use it in any of the following ways:
+
+```ruby
+class PostsController < ApplicationController
+  respond_to :html, :json
+
+  def index
+    # Filters out relevant attributes
+    # and applies scopes relevant to each
+    # parameter
+    @posts = Post.paraphrase(params)
+
+    # Or
+    # @posts = Paraphrase.query(:post, params)
+
+    # If you created a subclass
+    # @posts = PostQuery.new(params)
+
+    respond_with(@posts)
+  end
+end
+```
+
+In any of these contexts, the `:key` option of the `:scope` method registers
+attribute(s) to extract from the params supplied and what scope to pass them
+to. An array of keys can be supplied to pass multiple attributes to a scope.
+
+```ruby
+class Post < ActiveRecord::Base
+  register_mapping do
+    scope :by_user, :key => [:first_name, :last_name]
+  end
+
+  def self.by_user(name)
+    joins(:user).where(:user => { :name => name })
+  end
+end
+```
+
+If a key is required, pass `:require => true` to the options. This will
+return an empty results set if value for that key is missing.
+
+```ruby
+class Post < ActiveRecord::Base
+  register_mapping do
+    scope :by_author, :key => :author, :require => true
+    scope :published_after, :key => :pub_date
+  end
+end
+
+Post.paraphrase(:pub_date => '2010-10-30') # => []
+```
+
+## Plans
+
+* Enable requiring a subset of a compound key.
+
+```ruby
+scope :by_author, :key => [:first_name, :last_name], :require => :first_name
+```
+
+* Support nested hashes in params.
+
+```ruby
+scope :by_author, :key => { :author => [:first_name, :last_name] }
+```

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+require 'appraisal'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec

data/gemfiles/3.0.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source :rubygems
+
+gem "activerecord", "3.0.15"
+gem "activemodel", "3.0.15"
+gem "activesupport", "3.0.15"
+
+gemspec :path=>"../"

data/gemfiles/3.0.gemfile.lock

@@ -0,0 +1,57 @@
+PATH
+  remote: /Users/edd_d/src/paraphrase
+  specs:
+    paraphrase (0.1.0)
+      activemodel (~> 3.0)
+      activerecord (~> 3.0)
+      activesupport (~> 3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.15)
+      activesupport (= 3.0.15)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.15)
+      activemodel (= 3.0.15)
+      activesupport (= 3.0.15)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.15)
+    appraisal (0.4.1)
+      bundler
+      rake
+    arel (2.0.10)
+    builder (2.1.2)
+    diff-lcs (1.1.3)
+    i18n (0.5.0)
+    rake (0.9.2.2)
+    redcarpet (2.1.1)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    sqlite3 (1.3.6)
+    tzinfo (0.3.33)
+    yard (0.8.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (= 3.0.15)
+  activerecord (= 3.0.15)
+  activesupport (= 3.0.15)
+  appraisal
+  bundler (~> 1.0)
+  paraphrase!
+  rake
+  redcarpet
+  rspec (~> 2.10)
+  sqlite3
+  yard (~> 0.7)

data/gemfiles/3.1.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source :rubygems
+
+gem "activerecord", "3.1.6"
+gem "activemodel", "3.1.6"
+gem "activesupport", "3.1.6"
+
+gemspec :path=>"../"

data/gemfiles/3.1.gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: /Users/edd_d/src/paraphrase
+  specs:
+    paraphrase (0.1.0)
+      activemodel (~> 3.0)
+      activerecord (~> 3.0)
+      activesupport (~> 3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.6)
+      activesupport (= 3.1.6)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.6)
+      activemodel (= 3.1.6)
+      activesupport (= 3.1.6)
+      arel (~> 2.2.3)
+      tzinfo (~> 0.3.29)
+    activesupport (3.1.6)
+      multi_json (>= 1.0, < 1.3)
+    appraisal (0.4.1)
+      bundler
+      rake
+    arel (2.2.3)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    multi_json (1.2.0)
+    rake (0.9.2.2)
+    redcarpet (2.1.1)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    sqlite3 (1.3.6)
+    tzinfo (0.3.33)
+    yard (0.8.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (= 3.1.6)
+  activerecord (= 3.1.6)
+  activesupport (= 3.1.6)
+  appraisal
+  bundler (~> 1.0)
+  paraphrase!
+  rake
+  redcarpet
+  rspec (~> 2.10)
+  sqlite3
+  yard (~> 0.7)

data/gemfiles/3.2.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source :rubygems
+
+gem "activerecord", "3.2.6"
+gem "activemodel", "3.2.6"
+gem "activesupport", "3.2.6"
+
+gemspec :path=>"../"

data/gemfiles/3.2.gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: /Users/edd_d/src/paraphrase
+  specs:
+    paraphrase (0.1.0)
+      activemodel (~> 3.0)
+      activerecord (~> 3.0)
+      activesupport (~> 3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.6)
+      activesupport (= 3.2.6)
+      builder (~> 3.0.0)
+    activerecord (3.2.6)
+      activemodel (= 3.2.6)
+      activesupport (= 3.2.6)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.6)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    appraisal (0.4.1)
+      bundler
+      rake
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    i18n (0.6.0)
+    multi_json (1.3.6)
+    rake (0.9.2.2)
+    redcarpet (2.1.1)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    sqlite3 (1.3.6)
+    tzinfo (0.3.33)
+    yard (0.8.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (= 3.2.6)
+  activerecord (= 3.2.6)
+  activesupport (= 3.2.6)
+  appraisal
+  bundler (~> 1.0)
+  paraphrase!
+  rake
+  redcarpet
+  rspec (~> 2.10)
+  sqlite3
+  yard (~> 0.7)

data/lib/paraphrase/errors.rb

@@ -0,0 +1,4 @@
+module Paraphrase
+  class DuplicateMappingError < StandardError; end
+  class DuplicateScopeError < StandardError; end
+end

data/lib/paraphrase/query.rb

@@ -0,0 +1,86 @@
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/module/delegation'
+require 'active_model/naming'
+require 'active_model/errors'
+
+module Paraphrase
+  class Query
+    extend ActiveModel::Naming
+
+    # @!attribute [r] scopes
+    #   @return [Array<ScopeMapping>] scopes for query
+    #
+    # @!attribute [r] source
+    #   @return [ActiveRecord::Relation] source to apply scopes to
+    cattr_reader :scopes, :source
+    @@scopes = []
+
+
+    # Delegate enumerable methods to results
+    delegate :collect, :map, :each, :select, :to_a, :to_ary, :to => :results
+
+
+    # @!attribute [r] errors
+    #   @return [ActiveModel::Errors] errors from determining results
+    #
+    # @!attribute [r] params
+    #   @return [Hash] filters parameters based on keys defined in scopes
+    attr_reader :errors, :params
+
+
+    # Specify the ActiveRecord model to use as the source for queries
+    #
+    # @param [String, Symbol, ActiveRecord::Base] klass name of the class to
+    #   use or the class itself
+    def self.paraphrases(klass)
+      if !klass.is_a?(Class)
+        klass = Object.const_get(klass.to_s.classify)
+      end
+
+      @@source = klass.scoped
+
+      Paraphrase.add(klass.name, self)
+    end
+
+
+    # Add a {ScopeMapping} instance to {@@scopes .scopes}
+    #
+    # @see ScopeMapping#initialize
+    def self.scope(name, options)
+      if @@scopes.map(&:method_name).include?(name)
+        raise DuplicateScopeError, "scope :#{name} has already been added"
+      end
+
+      @@scopes << ScopeMapping.new(name, options)
+    end
+
+
+    # Filters out parameters irrelevant to the query
+    #
+    # @param [Hash] params query parameters
+    def initialize(params = {})
+      keys = scopes.map(&:param_keys).flatten
+      @params = params.dup
+      @params.select! { |key, value| keys.include?(key) }
+      @params.freeze
+
+      @errors = ActiveModel::Errors.new(self)
+    end
+
+
+    # Loops through {#scopes} and apply scope methods to {#source}. If values
+    # are missing for a required key, an empty array is returned.
+    #
+    # @return [ActiveRecord::Relation, Array]
+    def results
+      results ||= scopes.inject(source) do |query, scope|
+        scope.chain(self, @params, query)
+      end
+
+      @results = @errors.any? ? [] : results
+    end
+  end
+end
+
+require 'paraphrase/scope_mapping'

data/lib/paraphrase/rails.rb

@@ -0,0 +1,11 @@
+require 'rails'
+
+module Paraphrase
+  class Railtie < Rails::Railtie
+    initializer 'paraphrase.extend_active_record' do
+      ActiveSupport.on_load :active_record do
+        extend Paraphrase::Syntax
+      end
+    end
+  end
+end

data/lib/paraphrase/scope_mapping.rb

@@ -0,0 +1,55 @@
+module Paraphrase
+  class ScopeMapping
+    # @!attribute [r] param_keys
+    #   @return [Array<Symbol>] param keys to extract
+    #
+    # @!attribute [r] method_name
+    #   @return [Symbol] scope method name
+    #
+    # @!attribute [r] options
+    #   @return [Hash] configuration options
+    attr_reader :param_keys, :method_name, :options
+
+
+    # @param [Symbol] name name of the scope
+    # @param [Hash] options options to configure {ScopeMapping ScopeMapping} instance
+    # @option options [Symbol, Array<Symbol>] :key param key(s) to extract values from
+    # @option options [true] :require lists scope as required
+    def initialize(name, options)
+      @method_name = name
+      @param_keys = [options.delete(:key)].flatten
+
+      @options = options.freeze
+    end
+
+
+    # Checks if scope is required for query
+    def required?
+      !options[:require].nil?
+    end
+
+
+    # Sends {#method_name} to `chain`, extracting arguments from `params`.  If
+    # values are missing for any {#param_keys}, return the `chain` unmodified.
+    # If {#required? required}, errors are added to the {Query} instance as
+    # well.
+    #
+    # @param [Query] query {Query} instance applying the scope
+    # @param [Hash] params hash of query parameters
+    # @param [ActiveRecord::Relation, ActiveRecord::Base] chain current model scope
+    # @return [ActiveRecord::Relation]
+    def chain(query, params, chain)
+      inputs = param_keys.map { |key| params[key] }
+
+      if inputs.include?(nil)
+        param_keys.each do |key|
+          query.errors.add(key, 'is required')
+        end if required?
+
+        chain
+      else
+        chain.send(method_name, *inputs)
+      end
+    end
+  end
+end

data/lib/paraphrase/syntax.rb

@@ -0,0 +1,19 @@
+module Paraphrase
+  module Syntax
+
+    # Register a {Query} class mapped to `self`.
+    #
+    # @param [Proc] &block block to define scope mappings
+    def register_mapping(&block)
+      Paraphrase.register(self.name, &block)
+    end
+
+
+    # Instantiate the {Query} class that is mapped to `self`.
+    #
+    # @param [Hash] params query parameters
+    def paraphrase(params)
+      Paraphrase.query(self.name.underscore, params)
+    end
+  end
+end

data/lib/paraphrase/version.rb

@@ -0,0 +1,3 @@
+module Paraphrase
+  VERSION = "0.2.0"
+end

data/lib/paraphrase.rb

@@ -0,0 +1,65 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+
+module Paraphrase
+
+  @@mappings = {}.with_indifferent_access
+
+  # Allows for configuring multiple {Query} classes in a single block. Useful
+  # in an initializer.
+  def self.configure(&block)
+    yield self
+  end
+
+
+  # Retreive a registered Query subclass.
+  #
+  # @param [String, Symbol] name of the class underscored
+  # @return [Query]
+  def self.mapping(name)
+    @@mappings[name]
+  end
+
+
+  # Add a new subclass of Paraprhase::Query. The provided block is evaluated in
+  # the context of a Query subclass to define scope mappings.
+  #
+  # @param [String, Symbol] name name of the model in any inflector form
+  # @param [Proc] block defining mappings of scopes to keys for Query subclass
+  def self.register(name, &block)
+    klass = Class.new(Query, &block)
+    klass.paraphrases(name.to_s.classify)
+  end
+
+
+  # Register a subclass of Paraphrase::Query. Useful for manually subclassing
+  # Paraphrase::Query to add custom functionality.
+  #
+  # @param [String, Symbol] name name of the class in any ActiveSupport inflector form
+  # @param [Query] klass subclass of Paraphrase::Query
+  def self.add(name, klass)
+    name = name.to_s.underscore
+
+    if @@mappings[name]
+      raise DuplicateMappingError, "#{name.classify} has already been added"
+    end
+
+    @@mappings[name] = klass
+  end
+
+
+  # Instantiate a new Query subclass using supplied params
+  #
+  # @param [String, Symbol] name name of the model in underscored form
+  # @param [Hash] params hash of query params
+  # @return [Query]
+  def self.query(name, params)
+    @@mappings[name].new(params)
+  end
+end
+
+require 'paraphrase/errors'
+require 'paraphrase/query'
+require 'paraphrase/syntax'
+require 'paraphrase/rails' if defined?(Rails)

data/paraphrase.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/paraphrase/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "paraphrase"
+  gem.version       = Paraphrase::VERSION
+  gem.summary       = %q{Map param keys to class scopes}
+  gem.description   = %q{Map param keys to class scopes}
+  gem.license       = "MIT"
+  gem.authors       = ["Eduardo Gutierrez"]
+  gem.email         = "edd_d@mit.edu"
+  gem.homepage      = "https://rubygems.org/gems/paraphrase"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'activerecord', '~> 3.0'
+  gem.add_dependency 'activesupport', '~> 3.0'
+  gem.add_dependency 'activemodel', '~> 3.0'
+
+  gem.add_development_dependency 'bundler', '~> 1.0'
+  gem.add_development_dependency 'yard', '~> 0.7'
+  gem.add_development_dependency 'rspec', '~> 2.10'
+  gem.add_development_dependency 'redcarpet'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'appraisal'
+end

data/spec/paraphrase/query_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module Paraphrase
+  describe Query do
+
+    describe ".paraphrases" do
+      it "stores the class being queried" do
+        UserSearch.paraphrases :user
+        UserSearch.source.should eq User.scoped
+      end
+
+      it "registers the query in Paraphrase.querys" do
+        Paraphrase.mapping(:user).should eq UserSearch
+      end
+    end
+
+    describe ".scope" do
+      it "adds information to Query.scopes" do
+        UserSearch.instance_eval do
+          scope :name_like, :key => :name
+        end
+
+        UserSearch.scopes.should_not be_empty
+      end
+
+      it "raises an error if a scope is added twice" do
+        expect { UserSearch.instance_eval { scope :name_like, :key => :name } }.to raise_error Paraphrase::DuplicateScopeError
+      end
+    end
+
+    describe "#initialize" do
+      it "filters out params not specified in scopes" do
+        query = UserSearch.new(:name => 'Tyrion Lannister', :nickname => 'Half Man')
+
+        query.params.should_not have_key :nickname
+        query.params.should have_key :name
+      end
+    end
+
+    describe "#results" do
+      before :all do
+        UserSearch.instance_eval do
+          scope :title_like, :key => :title, :require => true
+        end
+      end
+
+      it "loops through scope methods and applies them to source" do
+        User.should_receive(:title_like).and_return(User.scoped)
+        User.should_receive(:name_like).and_return(User.scoped)
+
+        query = UserSearch.new(:name => 'Jon Snow', :title => 'Wall Watcher')
+        query.results
+      end
+
+      it "returns empty array if errors were added" do
+        query = UserSearch.new
+        query.results.should eq []
+        query.errors.should_not be_empty
+      end
+    end
+  end
+end

data/spec/paraphrase/scope_mapping_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Paraphrase
+  describe ScopeMapping do
+    let(:scope_mapping) do
+      ScopeMapping.new :name_like, :key => :name
+    end
+
+    it "removes keys from options" do
+      scope_mapping.options.should_not have_key :key
+    end
+
+    describe "#chain" do
+      let(:query) { double('query') }
+
+      it "applies scope method to query object with values from params hash" do
+        Account.should_receive(:name_like).with('Jon Snow')
+        scope_mapping.chain(query, { :name => 'Jon Snow' }, Account)
+      end
+
+      it "does nothing if values are missing" do
+        Account.should_not_receive(:name_like).with('Jon Snow')
+        scope_mapping.chain(query, {}, Account)
+      end
+
+      it "adds errors to query object if missing and required" do
+        errors = double('errors')
+        query.stub(:errors).and_return(errors)
+        required_mapping = ScopeMapping.new :name_like, :key => :name, :require => true
+
+        errors.should_receive(:add)
+        required_mapping.chain(query, {}, Account)
+      end
+    end
+  end
+end

data/spec/paraphrase/syntax_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Paraphrase
+  describe Syntax do
+    describe ".register_mapping" do
+      it "forwards to Paraphrase.register" do
+        ::Account.register_mapping {}
+        Paraphrase.mapping(:account).should_not be_nil
+      end
+    end
+
+    describe ".paraphrase" do
+      it "forwards to Paraphrase.query" do
+        Paraphrase.should_receive(:query).with('account', {})
+        ::Account.paraphrase({})
+      end
+    end
+  end
+end

data/spec/paraphrase_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Paraphrase do
+
+  describe ".configure" do
+    it "is a convenience method for configuring multiple query classes" do
+      Paraphrase.configure do |mapping|
+        mapping.register(:person) {}
+      end
+
+      Paraphrase.mapping(:person).should_not be_nil
+    end
+  end
+
+  describe ".register" do
+    it "a sublcass of Paraphrase::Query to @@mappings" do
+      Paraphrase.register(:foobar) {}
+      Paraphrase.mapping(:foobar).should_not be_nil
+    end
+
+    it "adds the source to the new subclass" do
+      Paraphrase.mapping(:foobar).source.should eq Foobar.scoped
+    end
+
+    it "raises an error if mappings for a class are added twice" do
+      expect { Paraphrase.register(:foobar) {} }.to raise_error Paraphrase::DuplicateMappingError
+    end
+  end
+
+  describe ".query" do
+    it "instantiates a new Query class" do
+      Paraphrase.query(:foobar, {}).should be_a Paraphrase::Query
+    end
+  end
+
+  describe ".add" do
+    it "adds class to mapping with specified name" do
+      klass = Class.new(Paraphrase::Query)
+      Paraphrase.add(:baz, klass)
+      Paraphrase.mapping(:baz).should eq klass
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'rspec'
+require 'paraphrase'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+)
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+
+  ActiveRecord::Schema.define do
+    create_table(:users, :force => true) {}
+    create_table(:accounts, :force => true) {}
+    create_table(:foobars, :force => true) {}
+    create_table(:people, :force => true) {}
+  end
+end
+
+class Person < ActiveRecord::Base
+end
+
+class Foobar < ActiveRecord::Base
+end
+
+class Account < ActiveRecord::Base
+  extend Paraphrase::Syntax
+end
+
+class User < ActiveRecord::Base
+end
+
+class UserSearch < Paraphrase::Query
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: paraphrase
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Eduardo Gutierrez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70178168974020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70178168974020
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70178168972120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70178168972120
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &70178168971600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70178168971600
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70178168971060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70178168971060
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70178168970400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: *70178168970400
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70178168969700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: *70178168969700
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: &70178168969060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70178168969060
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70178168968360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70178168968360
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70178168967600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70178168967600
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: &70178168966640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70178168966640
+description: Map param keys to class scopes
+email: edd_d@mit.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- .yardopts
+- Appraisals
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemfiles/3.0.gemfile
+- gemfiles/3.0.gemfile.lock
+- gemfiles/3.1.gemfile
+- gemfiles/3.1.gemfile.lock
+- gemfiles/3.2.gemfile
+- gemfiles/3.2.gemfile.lock
+- lib/paraphrase.rb
+- lib/paraphrase/errors.rb
+- lib/paraphrase/query.rb
+- lib/paraphrase/rails.rb
+- lib/paraphrase/scope_mapping.rb
+- lib/paraphrase/syntax.rb
+- lib/paraphrase/version.rb
+- paraphrase.gemspec
+- spec/paraphrase/query_spec.rb
+- spec/paraphrase/scope_mapping_spec.rb
+- spec/paraphrase/syntax_spec.rb
+- spec/paraphrase_spec.rb
+- spec/spec_helper.rb
+homepage: https://rubygems.org/gems/paraphrase
+licenses:
+- MIT
+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: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Map param keys to class scopes
+test_files:
+- spec/paraphrase/query_spec.rb
+- spec/paraphrase/scope_mapping_spec.rb
+- spec/paraphrase/syntax_spec.rb
+- spec/paraphrase_spec.rb
+- spec/spec_helper.rb
+has_rdoc: