sakuramochi 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "rails", ">= 3.0.0"
+
+group :development do
+  gem "sqlite3", "~> 1.3.4"
+  gem "rspec", "~> 2.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+end
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 mashiro
+
+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,64 @@
+# Sakuramochi
+
+Sakuramochi is a minimal active record extensions for Rails3.
+
+## Installation
+
+```ruby
+gem 'sakuramochi', :git => 'git://github.com/mashiro/sakuramochi.git'
+```
+
+## Getting started
+
+```ruby
+User.where(:name_contains => 'ai')
+# => "SELECT \"users\".* FROM \"users\"  WHERE (\"users\".\"name\" LIKE '%ai%')"
+
+User.where(:name_contains_any => ['ru', 'ai'])
+# => "SELECT \"users\".* FROM \"users\"  WHERE ((\"users\".\"name\" LIKE '%ru%' OR \"users\".\"name\" LIKE '%ai%'))"
+
+User.where(:name_contains_all => ['ru', 'ai'])
+# => "SELECT \"users\".* FROM \"users\"  WHERE ((\"users\".\"name\" LIKE '%ru%' AND \"users\".\"name\" LIKE '%ai%'))"
+```
+
+## Predicates
+
+* contains
+* starts_with, start_with
+* ends_with, end_with
+* in
+* eq, equal, equals
+* gt
+* gte, gteq
+* lt
+* lte, lteq
+
+## Configration
+
+```ruby
+Sakuramochi.configure do |config|
+  # simple
+  config.add :eq_amamiya,
+    :arel_predicate => :eq,
+    :converter => proc { |v| "amamiya #{v}" }
+
+  # advanced
+  config.add :surrounds_with, :surrounds_with_alias,
+    :arel_predicate => :matches,
+    :grouping => true,
+    :expand => false,
+    :converter => proc { |v| "#{v.first}%#{v.last}" },
+    :validator => proc { |v| true || v.is_a?(Enumerable) && v.to_a.size == 2 }
+end
+
+User.where(:name_eq_amamiya => 'rizumu')
+# => "SELECT \"users\".* FROM \"users\"  WHERE \"users\".\"name\" = 'amamiya rizumu'"
+
+User.where(:name_surrounds_with => ["ama", "umu"])
+# => "SELECT \"users\".* FROM \"users\"  WHERE (\"users\".\"name\" LIKE 'ama%umu')"
+```
+
+## Copyright
+
+Copyright (c) 2011 mashiro
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "sakuramochi"
+  gem.homepage = "http://github.com/mashiro/sakuramochi"
+  gem.license = "MIT"
+  gem.summary = %Q{Minimal active record extension plugin for Rails 3}
+  gem.description = %Q{Minimal active record extension plugin for Rails 3}
+  gem.email = "mail@mashiro.org"
+  gem.authors = ["mashiro"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sakuramochi #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/sakuramochi.rb

@@ -0,0 +1 @@
+require 'sakuramochi/railtie'

data/lib/sakuramochi/config.rb

@@ -0,0 +1,73 @@
+require 'sakuramochi/predicate'
+
+module Sakuramochi
+  def self.configure(&block)
+    yield @config ||= Sakuramochi::Configuration.new
+  end 
+
+  def self.config
+    @config
+  end 
+
+  class Configuration
+    attr_reader :predicates
+
+    def initialize
+      @predicates = {}
+    end 
+
+    def add(*args)
+      options = args.extract_options!
+      options.reverse_merge!(:grouping => true)
+      args.flatten.each do |name|
+        name = name.to_s
+
+        suffixes = [nil]
+        suffixes += ['any', 'all'] if options[:grouping]
+
+        suffixes.each do |suffix|
+          predicate_name = [name, suffix].compact.join('_')
+          @predicates[predicate_name] = Predicate.new(options.merge({
+            :name => predicate_name,
+            :arel_predicate => [options[:arel_predicate], suffix].compact.join('_')
+          }))
+        end
+      end 
+    end 
+
+    def clear
+      @predicates.clear
+    end
+  end 
+
+  configure do |config|
+    # default predicates
+    PREDICATES = {
+      :contains =>    [:contains],
+      :starts_with => [:starts_with, :start_with],
+      :ends_with =>   [:ends_with, :end_with],
+      :in =>          [:in],
+      :eq =>          [:eq, :equal, :equals],
+      :gt =>          [:gt],
+      :gte =>         [:gte, :gteq],
+      :lt =>          [:lt],
+      :lte =>         [:lte, :lteq],
+    }
+    _not = proc { |p| "not_#{p}" }
+
+    config.add PREDICATES[:contains],               :arel_predicate => :matches,        :converter => proc { |v| "%#{v}%" }
+    config.add PREDICATES[:contains].map(&_not),    :arel_predicate => :does_not_match, :converter => proc { |v| "%#{v}%" }
+    config.add PREDICATES[:starts_with],            :arel_predicate => :matches,        :converter => proc { |v| "#{v}%" }
+    config.add PREDICATES[:starts_with].map(&_not), :arel_predicate => :does_not_match, :converter => proc { |v| "#{v}%" }
+    config.add PREDICATES[:ends_with],              :arel_predicate => :matches,        :converter => proc { |v| "%#{v}" }
+    config.add PREDICATES[:ends_with].map(&_not),   :arel_predicate => :does_not_match, :converter => proc { |v| "%#{v}" }
+    config.add PREDICATES[:in],                     :arel_predicate => :in
+    config.add PREDICATES[:in].map(&_not),          :arel_predicate => :not_in
+    config.add PREDICATES[:eq],                     :arel_predicate => :eq
+    config.add PREDICATES[:eq].map(&_not), :ne,     :arel_predicate => :not_eq
+    config.add PREDICATES[:gt],                     :arel_predicate => :gt
+    config.add PREDICATES[:gte],                    :arel_predicate => :gteq
+    config.add PREDICATES[:lt],                     :arel_predicate => :lt
+    config.add PREDICATES[:lte],                    :arel_predicate => :lteq
+  end 
+end

data/lib/sakuramochi/predicate.rb

@@ -0,0 +1,51 @@
+require 'sakuramochi/config'
+
+module Sakuramochi
+  class Predicate
+    attr_reader :name, :arel_predicate, :expand, :converter, :validator
+
+    def initialize(options = {}) 
+      options = options.reverse_merge(:expand => true)
+      @name = options[:name]
+      @arel_predicate = options[:arel_predicate]
+      @expand = options[:expand]
+      @converter = options[:converter]
+      @validator = options[:validator] || proc { |v| v.respond_to?(:empty?) ? !v.empty? : !v.nil? }
+    end 
+
+    def convert(value)
+      return value unless @converter
+      if @expand
+        Predicate.as_a(value).map { |v| @converter.call(v) }
+      else
+        @converter.call(value)
+      end
+    end 
+
+    def validate(value)
+      if @expand
+        Predicate.as_a(value).select { |v| @validator.call(v) }.any?
+      else
+        @validator.call(value)
+      end
+    end 
+
+    def self.as_a(value)
+      value.is_a?(Enumerable) ? value.to_a : [value]
+    end
+
+    def self.names
+      Sakuramochi.config.predicates.keys
+    end 
+
+    def self.names_by_decreasing_length
+      names.sort { |a, b| b.length <=> a.length }
+    end 
+
+    def self.detect(attr)
+      attr_name = attr.to_s.dup
+      pred_name = names_by_decreasing_length.detect {|p| attr_name.sub!(/_#{p}$/, '')}
+      [attr_name, Sakuramochi.config.predicates[pred_name]]
+    end 
+  end 
+end

data/lib/sakuramochi/predicate_builder.rb

@@ -0,0 +1,93 @@
+require 'sakuramochi/predicate'
+require 'active_support/concern'
+
+module Sakuramochi
+  module PredicateBuilder
+    extend ActiveSupport::Concern
+
+    included do
+      instance_eval do
+        alias :build_from_hash_without_predicate :build_from_hash
+        alias :build_from_hash :build_from_hash_with_predicate
+      end
+    end
+
+    module ClassMethods
+      def build_from_hash_with_predicate(engine, attributes, default_table)
+        predicates = attributes.map do |column, value|
+          table = default_table
+
+          if value.is_a?(Hash)
+            table = Arel::Table.new(column, engine)
+            build_from_hash(engine, value, table)
+          else
+            column = column.to_s
+
+            if column.include?('.')
+              table_name, column = column.split('.', 2)
+              table = Arel::Table.new(table_name, engine)
+            end 
+
+            column_name, predicate = Predicate.detect(column.to_s)
+            attribute = table[column_name.to_sym]
+
+            if predicate
+              build_attribute_with_predicate(attribute, value, predicate)
+            else
+              build_attribute(attribute, value)
+            end
+          end
+        end
+
+        predicates.flatten.compact
+      end
+
+      def build_attribute_with_predicate(attribute, value, predicate)
+        if predicate.validate(value)
+          if predicate.converter
+            attribute.send(predicate.arel_predicate, predicate.convert(value))
+          else
+            relation = build_attribute(attribute, value)
+            attribute.send(predicate.arel_predicate, relation.right)
+          end
+        else
+          ''
+        end
+      end
+
+      def build_attribute(attribute, value)
+        case value
+        when ActiveRecord::Relation
+          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+          attribute.in(value.arel.ast)
+        when Array, ActiveRecord::Associations::CollectionProxy
+          values = value.to_a.map { |x|
+            x.is_a?(ActiveRecord::Base) ? x.id : x
+          }
+
+          if values.include?(nil)
+            values = values.compact
+            if values.empty?
+              attribute.eq nil
+            else
+              attribute.in(values.compact).or attribute.eq(nil)
+            end
+          else
+            attribute.in(values)
+          end
+
+        when Range, Arel::Relation
+          attribute.in(value)
+        when ActiveRecord::Base
+          attribute.eq(value.id)
+        when Class
+          # FIXME: I think we need to deprecate this behavior
+          attribute.eq(value.name)
+        else
+          attribute.eq(value)
+        end
+      end
+    end
+
+  end
+end

data/lib/sakuramochi/railtie.rb

@@ -0,0 +1,18 @@
+require 'rails'
+require 'sakuramochi/config'
+require 'sakuramochi/predicate'
+require 'sakuramochi/predicate_builder'
+
+module Sakuramochi
+  class Railtie < Rails::Railtie
+    initializer 'sakuramochi.initialize' do
+      ActiveSupport.on_load(:active_record) do
+        Railtie.setup
+      end
+    end 
+
+    def self.setup
+      ActiveRecord::PredicateBuilder.send(:include, Sakuramochi::PredicateBuilder)
+    end
+  end 
+end

data/sakuramochi.gemspec

@@ -0,0 +1,72 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "sakuramochi"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["mashiro"]
+  s.date = "2011-10-13"
+  s.description = "Minimal active record extension plugin for Rails 3"
+  s.email = "mail@mashiro.org"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/sakuramochi.rb",
+    "lib/sakuramochi/config.rb",
+    "lib/sakuramochi/predicate.rb",
+    "lib/sakuramochi/predicate_builder.rb",
+    "lib/sakuramochi/railtie.rb",
+    "sakuramochi.gemspec",
+    "spec/sakuramochi/config_spec.rb",
+    "spec/sakuramochi/predicate_builder_spec.rb",
+    "spec/sakuramochi/predicate_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/schema.rb"
+  ]
+  s.homepage = "http://github.com/mashiro/sakuramochi"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Minimal active record extension plugin for Rails 3"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 3.0.0"])
+      s.add_development_dependency(%q<sqlite3>, ["~> 1.3.4"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, [">= 3.0.0"])
+      s.add_dependency(%q<sqlite3>, ["~> 1.3.4"])
+      s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 3.0.0"])
+    s.add_dependency(%q<sqlite3>, ["~> 1.3.4"])
+    s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/spec/sakuramochi/config_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Sakuramochi::Configuration do
+  before do
+    Sakuramochi.configure do |config|
+      config.clear
+      @config = config
+    end
+  end
+  subject { @config }
+
+  describe '#configure' do
+    it { should be_an_instance_of Sakuramochi::Configuration }
+    its(:object_id) { should eq Sakuramochi.config.object_id }
+  end
+
+  describe '#clear' do
+    before do
+      @config.add :test1
+      @config.add :test2
+      @config.add :test3, :test4
+      @config.clear
+    end
+    subject { @config.predicates }
+
+    it { should be_empty }
+  end
+
+  describe '#add' do
+    before do
+      @config.add :test1, :grouping => true
+      @config.add :test2, :grouping => false
+    end
+    subject { @config.predicates }
+
+    it { should_not be_empty }
+
+    context 'with :test1, :grouping => true' do
+      it { should have_key 'test1' }
+      it { should have_key 'test1_any' }
+      it { should have_key 'test1_all' }
+    end
+
+    context 'with :test2, :grouping => false' do
+      it { should have_key 'test2' }
+      it { should_not have_key 'test2_any' }
+      it { should_not have_key 'test2_all' }
+    end
+  end
+end

data/spec/sakuramochi/predicate_builder_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+RSpec::Matchers.define :be_match_all do |expected|
+  match do |actuals|
+    actuals.all? { |actual| !!(actual =~ expected) }
+  end
+end
+
+describe Sakuramochi::PredicateBuilder do
+  before(:all) do
+    @aira = User.create! :name => 'harune aira'
+    ['fresh fruit basket', 'munekyun taiken', 'heartful splash',
+     'lovely rainbow', 'hirahira hiraku koi no hana', 'crystal splash'
+    ].each do |jump|
+      Status.create! :text => jump, :user => @aira
+    end
+
+    @rizumu = User.create! :name => 'amamiya rizumu'
+    ['heartful splash', 'colorful choco parade', 'fun fun heart dive',
+     'stardust shower', 'happy macaron spin', 'pop\'n candy rocket'
+    ].each do |jump|
+      Status.create! :text => jump, :user => @rizumu
+    end
+  end
+
+  describe 'matches' do
+    before do
+      Sakuramochi.configure do |config|
+        config.clear
+        config.add :contains, :arel_predicate => :matches, :converter => proc { |v| "%#{v}%" }
+      end
+      @statuses = Status.where(key => value)
+    end
+    subject { @statuses }
+
+    shared_examples_for :never_match do
+      let(:value) { 'NEVER MATCH' }
+      it { should be_empty }
+    end
+
+    context 'contains' do
+      let(:key) { :text_contains }
+      context 'with "macaron"' do
+        let(:value) { 'macaron' }
+
+        it_should_behave_like :never_match
+        it { should have(1).items }
+        it { subject.map(&:text).should be_match_all /macaron/ }
+      end
+
+      context 'with "splash"' do
+        let(:value) { 'splash' }
+
+        it_should_behave_like :never_match
+        it { should have(3).items }
+        it { subject.map(&:text).should be_match_all /splash/ }
+      end
+    end
+
+    context 'contains_any' do
+      let(:key) { :text_contains_any }
+      context 'with ["heart", "splash"]' do
+        let(:value) { ['heart', 'splash'] }
+
+        it_should_behave_like :never_match
+        it { should have(4).items }
+        it { subject.map(&:text).should be_match_all /(heart|splash)/ }
+      end
+    end
+
+    context 'contains_all' do
+      let(:key) { :text_contains_all }
+      context 'with ["heart", "splash"]' do
+        let(:value) { ['heart', 'splash'] }
+
+        it_should_behave_like :never_match
+        it { should have(2).items }
+        it { subject.map(&:text).should be_match_all /heart/ }
+        it { subject.map(&:text).should be_match_all /splash/ }
+      end
+    end
+  end
+end

data/spec/sakuramochi/predicate_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Sakuramochi::Predicate do
+  describe '#convert' do
+    before do
+      @pred = Sakuramochi::Predicate.new :converter => converter
+    end
+
+    context 'default converter' do
+      let(:converter) { nil }
+      subject { @pred.convert(3) }
+
+      it { should eq 3 }
+    end
+
+    context 'custom converter' do
+      let(:converter) { proc { |v| v * v } }
+
+      context 'as unit' do
+        subject { @pred.convert(3) }
+        it { should eq [9] }
+      end
+
+      context 'as array' do
+        subject { @pred.convert([1,2,3]) }
+        it { should eq [1,4,9] }
+      end
+
+      context 'as range' do
+        subject { @pred.convert(1..3) }
+        it { should eq [1,4,9] }
+      end
+    end
+  end
+
+  describe '#validate' do
+    before do
+      @pred = Sakuramochi::Predicate.new :validator => validator
+    end
+
+    context 'default validator' do
+      let(:validator) { nil }
+
+      context 'with "value"' do
+        subject { @pred.validate('value') }
+        it { should be_true }
+      end
+
+      context 'with empty' do
+        subject { @pred.validate('') }
+        it { should be_false }
+      end
+
+      context 'with nil' do
+        subject { @pred.validate(nil) }
+        it { should be_false }
+      end
+    end
+
+    context 'custom validator: greater then 3' do
+      let(:validator) { proc { |v| v > 3 } }
+
+      context 'with 2' do
+        subject { @pred.validate(2) }
+        it { should be_false }
+      end
+
+      context 'with 4' do
+        subject { @pred.validate(4) }
+        it { should be_true }
+      end
+
+      context 'with (1..3)' do
+        subject { @pred.validate(1..3) }
+        it { should be_false }
+      end
+
+      context 'with (1..5)' do
+        subject { @pred.validate(1..5) }
+        it { should be_true }
+      end
+    end
+  end
+
+  describe '#detect' do
+    context 'config.add :test' do
+      before do
+        Sakuramochi.configure do |config|
+          config.add :test
+        end
+      end
+
+      context 'with :username_test' do
+        before { @name, @pred = Sakuramochi::Predicate.detect(:username_test) }
+        subject { {:name => @name, :pred => @pred } }
+        its([:name]) { should eq 'username' }
+        its([:pred]) { should be_instance_of Sakuramochi::Predicate }
+      end
+
+      context 'with :username_test2' do
+        before { @name, @pred = Sakuramochi::Predicate.detect(:username_test2) }
+        subject { {:name => @name, :pred => @pred } }
+        its([:name]) { should eq 'username_test2' }
+        its([:pred]) { should be_nil }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'sakuramochi'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    CreateTestTables.up
+    Sakuramochi::Railtie.setup
+  end
+end

data/spec/support/schema.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+
+ActiveRecord::Base.configurations = {'test' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('test')
+
+class User < ActiveRecord::Base
+  has_many :statuses
+end
+
+class Status < ActiveRecord::Base
+  belongs_to :user
+end
+
+class CreateTestTables < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :name
+      t.integer :age
+    end
+
+    create_table :statuses do |t|
+      t.references :user
+      t.string :text
+    end
+  end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: sakuramochi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- mashiro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-13 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &27264080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *27264080
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &27263600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.4
+  type: :development
+  prerelease: false
+  version_requirements: *27263600
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &27263040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *27263040
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &27262520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *27262520
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &27261880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *27261880
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &27261220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *27261220
+description: Minimal active record extension plugin for Rails 3
+email: mail@mashiro.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/sakuramochi.rb
+- lib/sakuramochi/config.rb
+- lib/sakuramochi/predicate.rb
+- lib/sakuramochi/predicate_builder.rb
+- lib/sakuramochi/railtie.rb
+- sakuramochi.gemspec
+- spec/sakuramochi/config_spec.rb
+- spec/sakuramochi/predicate_builder_spec.rb
+- spec/sakuramochi/predicate_spec.rb
+- spec/spec_helper.rb
+- spec/support/schema.rb
+homepage: http://github.com/mashiro/sakuramochi
+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'
+      segments:
+      - 0
+      hash: -4419155070054156166
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Minimal active record extension plugin for Rails 3
+test_files: []