activerecord-futures 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-futures.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Leonardo Andres Garcia Crespo
+
+MIT License
+
+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,93 @@
+# ActiveRecord::Futures
+
+Define future queries in ActiveRecord that will get executed in a single round trip to the database.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord-futures'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-futures
+
+## Usage
+
+Currently, the only database supported is MySQL, and with a special adapter, provided by the gem.
+
+Set your config/database.yml file to use the given adapter:
+
+```yml
+development: &development
+  adapter: future_enabled_mysql2 # set this adapter for futures to work!
+  username: your_username
+  password: your_password
+  database: your_database
+  host: your_host
+```
+
+Now let's see what this does, consider a model `User`, with a `:name` attribute:
+
+```ruby
+# Build the queries and mark them as futures
+users = User.where("name like 'John%'").future # becomes a future relation, does not execute the query.
+count = User.where("name like 'John%'").future_count # becomes a future calculation, does not execute the query.
+
+# Execute any of the futures
+count = count.value # trigger the future execution, both queries will get executed in one round trip!
+#=> User Load (fetching Futures) (0.6ms)  SELECT `users`.* FROM `users` WHERE (name like 'John%');SELECT COUNT(*) FROM `users` WHERE (name like 'John%')
+
+# Access the other results
+users = users.to_a # does not execute the query, results from previous query get loaded
+```
+
+Any amount of futures can be prepared, and the will get executed as soon as one of them needs to be evaluated.
+
+### Methods
+
+ActiveRecord::Relation instances get a `future` method for all queries where multiple results are returned. The future gets
+executed whenever `#to_a` gets executed. Note that, as ActiveRecord does, enumerable methods get delegated to `#to_a` also,
+so things like `#each`, `#map`, `#collect` all trigger the future.
+
+Also, ActiveRecord::Relation instances get all the calculation methods provided by the ActiveRecord::Calculations module
+"futurized", that means, for `#count` you get `#future_count`, for `#sum` you get `#future_sum` and so on. These future
+calculations are triggered by executing the `#value` method, which also return the actual result of the calculation.
+
+## Database support
+
+### SQlite
+
+SQlite doesn't support multiple statement queries. Currently this gem doesn't fall back to the normal behavior if the
+adapter does not support futures, but this is in the road map :)
+
+### MySQL
+
+Multi statement queries are supported by the mysql2 gem since version 0.3.12b1, so you'll need to use that one or a newer
+one.
+Currently the adapter provided is the same as the built-in in Rails, but it also sets the MULTI_STATEMENTS flag to allow
+multiple queries in a single command. It also has a special way to
+execute the queries in order to fetch the results correctly. You
+can check the code if you're curious!
+
+### Postgres
+
+Coming soon!
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Roadmap
+
+1. Support for postgres
+2. Fallback to normal queries when adapter does not support futures
+3. Think of a way to use the normal adapters

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/activerecord-futures.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord-futures/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "activerecord-futures"
+  gem.version       = Activerecord::Futures::VERSION
+  gem.authors       = ["Leonardo Andres Garcia Crespo"]
+  gem.email         = ["leoasis@gmail.com"]
+  gem.description   = %q{Save unnecessary round trips to the database}
+  gem.summary       = %q{Fetch all queries at once from the database and save round trips. }
+  gem.homepage      = "https://github.com/leoasis/activerecord-futures"
+
+  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.2.13'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec-spies'
+end

data/lib/active_record/connection_adapters/future_enabled_mysql2_adapter.rb

@@ -0,0 +1,51 @@
+require "active_record/connection_adapters/mysql2_adapter"
+
+module ActiveRecord
+  class Base
+    def self.future_enabled_mysql2_connection(config)
+      config = config.symbolize_keys
+
+      config[:username] = 'root' if config[:username].nil?
+
+      if Mysql2::Client.const_defined? :FOUND_ROWS
+        config[:flags] = Mysql2::Client::FOUND_ROWS | Mysql2::Client::MULTI_STATEMENTS
+      end
+      client = Mysql2::Client.new(config)
+      options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+      ConnectionAdapters::FutureEnabledMysql2Adapter.new(client, logger, options, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class FutureEnabledMysql2Adapter < Mysql2Adapter
+
+      def supports_futures?
+        true
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        my_future = Futures::Future.current
+
+        # default behavior if not a current future
+        return super unless my_future
+
+        # return fulfilled result, if exists, to load the relation
+        return my_future.result if my_future.fulfilled?
+
+        futures = Futures::Future.all
+
+        futures_sql = futures.map(&:to_sql).join(';')
+        name = "#{name} (fetching Futures)"
+
+        result = execute(futures_sql, name)
+
+        futures.each do |future|
+          future.fulfill(ActiveRecord::Result.new(result.fields, result.to_a))
+          result = @connection.store_result if @connection.next_result
+        end
+
+        my_future.result
+      end
+    end
+  end
+end

data/lib/active_record/futures/delegation.rb

@@ -0,0 +1,8 @@
+module ActiveRecord
+  module Futures
+    module Delegation
+      delegate :future, to: :scoped
+      delegate *Futures.future_calculation_methods, to: :scoped
+    end
+  end
+end

data/lib/active_record/futures/future.rb

@@ -0,0 +1,72 @@
+module ActiveRecord
+  module Futures
+    class Future
+      class << self
+        def futures
+          Thread.current["#{self.name}_futures"] ||= []
+        end
+        alias_method :all, :futures
+
+        def current
+          Thread.current["#{self.name}_current"]
+        end
+
+        def current=(future)
+          Thread.current["#{self.name}_current"] = future
+        end
+
+        def clear
+          all.clear
+        end
+
+        def register(future)
+          self.futures << future
+        end
+
+        def flush
+          self.futures.each(&:load)
+          clear
+        end
+      end
+
+
+      attr_reader :result
+
+      def initialize
+        Future.register(self)
+      end
+
+      def fulfill(result)
+        @result = result
+      end
+
+      def fulfilled?
+        !result.nil?
+      end
+
+      def load
+        Future.current = self
+        execute
+        Future.current = nil
+      end
+
+      def inspect
+        to_a.inspect
+      end
+
+      def to_sql
+      end
+      undef_method :to_sql
+
+    private
+      def execute
+      end
+      undef_method :execute
+
+      def executed?
+      end
+      undef_method :executed?
+
+    end
+  end
+end

data/lib/active_record/futures/future_calculation.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  module Futures
+    class FutureCalculation < Future
+      attr_reader :query, :execution
+      private :query, :execution
+
+      def initialize(query, execution)
+        super()
+        @query = query
+        @execution = execution
+      end
+
+      def value
+        Future.flush unless executed?
+        @value
+      end
+
+      def inspect
+        value.inspect
+      end
+
+      def to_sql
+        query
+      end
+
+    private
+
+      def execute
+        @value = execution.call
+        @executed = true
+      end
+
+      def executed?
+        @executed
+      end
+    end
+  end
+end

data/lib/active_record/futures/future_relation.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  module Futures
+    class FutureRelation < Future
+      include Delegation
+      delegate :to_sql, to: :relation
+
+      attr_reader :relation
+      private :relation
+
+      def initialize(relation)
+        super()
+        @relation = relation
+        @klass = relation.klass
+      end
+
+      def to_a
+        # Flush all the futures upon first attempt to exec a future
+        Future.flush unless executed?
+        execute
+      end
+
+    private
+
+      def execute
+        relation.to_a
+      end
+
+      def executed?
+        relation.loaded?
+      end
+    end
+  end
+end

data/lib/active_record/futures/query_recording.rb

@@ -0,0 +1,69 @@
+module ActiveRecord
+  module Futures
+    module QueryRecording
+
+    private
+      def record_query
+        orig_klass = @klass
+        connection = ConnectionProxy.new(@klass.connection)
+        @klass = KlassProxy.new(@klass, connection)
+        yield
+        connection.recorded_query
+      ensure
+        @klass = orig_klass
+      end
+
+      class KlassProxy
+        attr_reader :klass, :connection
+
+        def initialize(klass, connection)
+          @klass = klass
+          @connection = connection
+        end
+
+        def method_missing(method, *args, &block)
+          if klass.respond_to?(method)
+            klass.send(method, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method, include_all = false)
+          super || klass.respond_to?(method, include_all)
+        end
+      end
+
+      class ConnectionProxy
+        attr_reader :connection
+        attr_accessor :recorded_query
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def select_value(arel, name = nil)
+          self.recorded_query = arel.to_sql
+          nil
+        end
+
+        def select_all(arel, name = nil, binds = [])
+          self.recorded_query = arel.to_sql
+          []
+        end
+
+        def method_missing(method, *args, &block)
+          if connection.respond_to?(method)
+            connection.send(method, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method, include_all = false)
+          super || connection.respond_to?(method, include_all)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/futures.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module Futures
+    include QueryRecording
+
+    def self.original_calculation_methods
+      ActiveRecord::Calculations.public_instance_methods
+    end
+
+    def self.future_calculation_methods
+      original_calculation_methods.map { |name| "future_#{name}" }
+    end
+
+    def future
+      supports_futures = connection.respond_to?(:supports_futures?) &&
+                         connection.supports_futures?
+
+      # simply pass through if the connection adapter does not support
+      # futures
+      supports_futures ? FutureRelation.new(self) : self
+    end
+
+    method_table = Hash[future_calculation_methods.zip(original_calculation_methods)]
+
+    # define a "future_" method for each calculation method
+    #
+    method_table.each do |future_method, method|
+      define_method(future_method) do |*args, &block|
+        exec = lambda { send(method, *args, &block) }
+        query = record_query(&exec)
+        FutureCalculation.new(query, exec)
+      end
+    end
+  end
+end

data/lib/activerecord-futures/version.rb

@@ -0,0 +1,5 @@
+module Activerecord
+  module Futures
+    VERSION = "0.0.1"
+  end
+end

data/lib/activerecord-futures.rb

@@ -0,0 +1,21 @@
+require 'active_record'
+require 'active_support/core_ext/module/delegation'
+require "activerecord-futures/version"
+
+require "active_record/futures/future"
+require "active_record/futures/future_relation"
+require "active_record/futures/future_calculation"
+
+require "active_record/futures/query_recording"
+require "active_record/futures"
+require "active_record/futures/delegation"
+
+module ActiveRecord
+  class Relation
+    include Futures
+  end
+
+  class Base
+    extend Futures::Delegation
+  end
+end

data/spec/active_record/futures/future_relation_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+module ActiveRecord::Futures
+  describe FutureRelation do
+    let(:relation) { double(ActiveRecord::Relation, klass: Class.new, to_a: nil) }
+    subject { FutureRelation.new(relation) }
+
+    describe ".new" do
+      before do
+        subject
+      end
+
+      it "gets registered" do
+        Future.all.should have(1).future
+        Future.all.first.should == subject
+      end
+
+      its(:relation) { should eq relation }
+
+      it { should_not be_fulfilled }
+    end
+
+    describe "#fulfill" do
+      let(:result) { "Some cool result" }
+
+      before do
+        subject.fulfill(result)
+      end
+
+      it { should be_fulfilled }
+    end
+
+    describe "#load" do
+      before do
+        relation.stub(:to_a) do
+          @current_future = Future.current
+          nil
+        end
+
+        subject.load
+      end
+
+      it "calls #to_a in the relation" do
+        relation.should have_received(:to_a)
+      end
+
+      it "sets the current future to itself while #to_a was being called in the relation" do
+        @current_future.should == subject
+      end
+
+      it "sets to nil the current future afterwards" do
+        Future.current.should == nil
+      end
+    end
+  end
+end

data/spec/active_record/futures/future_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module ActiveRecord::Futures
+  describe Future do
+    context "class methods" do
+      describe ".futures" do
+        context "with futures in two threads" do
+          let(:futures_key) { "#{Future.name}_futures" }
+
+          let(:a_thread) do
+            thread = double("Thread 1")
+            thread.stub(:[]).with(futures_key).and_return([])
+            thread
+          end
+
+          let(:another_thread) do
+            thread = double("Thread 2")
+            thread.stub(:[]).with(futures_key).and_return([])
+            thread
+          end
+
+          before do
+            Thread.stub(:current).and_return(a_thread)
+
+            Future.futures << "Future 1"
+            Future.futures << "Future 2"
+
+            Thread.stub(:current).and_return(another_thread)
+
+            Future.futures << "Future 3"
+            Future.futures << "Future 4"
+          end
+
+          context "the futures in thread 1" do
+            let(:futures) { a_thread[futures_key] }
+
+            specify { futures.should include("Future 1") }
+            specify { futures.should include("Future 2") }
+            specify { futures.should_not include("Future 3") }
+            specify { futures.should_not include("Future 4") }
+          end
+
+          context "the futures in thread 2" do
+            let(:futures) { another_thread[futures_key] }
+
+            specify { futures.should_not include("Future 1") }
+            specify { futures.should_not include("Future 2") }
+            specify { futures.should include("Future 3") }
+            specify { futures.should include("Future 4") }
+          end
+        end
+      end
+
+      describe ".current" do
+        context "with currents in two threads" do
+          let(:current_key) { "#{Future.name}_current" }
+
+          let(:a_thread) do
+            thread = Hash.new
+          end
+
+          let(:another_thread) do
+            thread = Hash.new
+          end
+
+          before do
+            Thread.stub(:current).and_return(a_thread)
+
+            Future.current = "Future 1"
+
+            Thread.stub(:current).and_return(another_thread)
+
+            Future.current = "Future 2"
+          end
+
+          context "the current in thread 1" do
+            let(:current) { a_thread[current_key] }
+
+            specify { current.should eq "Future 1" }
+          end
+
+          context "the current in thread 2" do
+            let(:current) { another_thread[current_key] }
+
+            specify { current.should eq "Future 2" }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/db/schema.rb

@@ -0,0 +1,16 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table "countries", :force => true do |t|
+    t.string   "name"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+
+  create_table "users", :force => true do |t|
+    t.string   "name"
+    t.string   "email"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+
+end

data/spec/in_action/future_fulfillment_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+module ActiveRecord::Futures
+  describe "Future fulfillment" do
+    subject { Future }
+
+    context "when futurizing a relation" do
+      let!(:future) { User.where(name: "").future }
+
+      its(:all) { should have(1).future }
+
+      context "the relation future" do
+        specify { future.should_not be_fulfilled }
+      end
+
+      context "and executing it" do
+        before { future.to_a }
+
+        its(:all) { should have(0).futures }
+
+        context "the future" do
+          subject { future }
+
+          it { should be_fulfilled }
+        end
+      end
+    end
+
+    context "when futurizing two relations" do
+      let!(:future) { User.where(name: "").future }
+      let!(:another_future) { Country.where(name: "").future }
+
+      its(:all) { should have(2).futures }
+
+      context "the first relation future" do
+        specify { future.should_not be_fulfilled }
+      end
+
+      context "the other relation future" do
+        specify { another_future.should_not be_fulfilled }
+      end
+
+      context "and executing one of them" do
+        before { future.to_a }
+
+        its(:all) { should have(0).futures }
+
+        context "the first relation future" do
+          specify { future.should be_fulfilled }
+        end
+
+        context "the other relation future" do
+          specify { another_future.should be_fulfilled }
+        end
+      end
+
+      context "and executing another non futurized relation" do
+        let!(:normal_relation) { User.where(name: "") }
+        before { normal_relation.to_a }
+
+        its(:all) { should have(2).futures }
+
+        context "the first relation future" do
+          specify { future.should_not be_fulfilled }
+        end
+
+        context "the other relation future" do
+          specify { another_future.should_not be_fulfilled }
+        end
+      end
+    end
+  end
+end

data/spec/models/country.rb

@@ -0,0 +1,2 @@
+class Country < ActiveRecord::Base
+end

data/spec/models/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'activerecord-futures'
+
+config = {
+  adapter: "future_enabled_mysql2",
+  database: "test",
+  username: "root",
+  password: "root",
+  database: "activerecord_futures_test",
+  host: "localhost"
+}
+
+ActiveRecord::Base.establish_connection(config)
+require 'db/schema'
+
+Dir[File.join(File.dirname(__FILE__), 'models/**/*')].each { |f| require f }
+
+require 'rspec-spies'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.after do
+    ActiveRecord::Futures::Future.clear
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-futures
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Leonardo Andres Garcia Crespo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-spies
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Save unnecessary round trips to the database
+email:
+- leoasis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-futures.gemspec
+- lib/active_record/connection_adapters/future_enabled_mysql2_adapter.rb
+- lib/active_record/futures.rb
+- lib/active_record/futures/delegation.rb
+- lib/active_record/futures/future.rb
+- lib/active_record/futures/future_calculation.rb
+- lib/active_record/futures/future_relation.rb
+- lib/active_record/futures/query_recording.rb
+- lib/activerecord-futures.rb
+- lib/activerecord-futures/version.rb
+- spec/active_record/futures/future_relation_spec.rb
+- spec/active_record/futures/future_spec.rb
+- spec/db/schema.rb
+- spec/in_action/future_fulfillment_spec.rb
+- spec/models/country.rb
+- spec/models/user.rb
+- spec/spec_helper.rb
+homepage: https://github.com/leoasis/activerecord-futures
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Fetch all queries at once from the database and save round trips.
+test_files:
+- spec/active_record/futures/future_relation_spec.rb
+- spec/active_record/futures/future_spec.rb
+- spec/db/schema.rb
+- spec/in_action/future_fulfillment_spec.rb
+- spec/models/country.rb
+- spec/models/user.rb
+- spec/spec_helper.rb
+has_rdoc: