rectify 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7db41f0a655c68a1cc60f253b0bca46e049be1e
-  data.tar.gz: 18cff71a5e52be32ec14c25df243b3aa1bdb4338
+  metadata.gz: e805f930c1178fd2d4b9b8672208711752d5c2ef
+  data.tar.gz: 1d53aeaaa143f2014c377d83db35b8c82f6adf0e
 SHA512:
-  metadata.gz: c014786d12349c161f38d17d5249156fc206e21fa43da1061d4237f72778a17ca2190353eb99d6a004ae39a2a5abbe9a9bbede7c0aaff187aa8fd62c2f3f3f4d
-  data.tar.gz: 16590d5c8313f1570612c1fc7d0308a0e3b848ed8cc8bb20c5afcb9ce073434abec5a68383c70f2e5896b51c77d5d242e62dcbfc583157655b23e79d03dfb1d5
+  metadata.gz: b74e8c3a073953f597603a1f248e7c2b7c17e82b917475c2de124f3a86f7ba7038cf8325198384e18be39e5186866b6e4bb36e8e06b914aa54820ca644abccf0
+  data.tar.gz: e27148d4f4c7122ae23032d9f868b39ea4f012980511856305d46d0f7244dafac27ec2b45a84828387f94eb8adb72b39a8c8e17bf7b5f6f4c3544c5e714b61dd

data/lib/rectify/controller_helpers.rb

@@ -7,7 +7,7 @@ module Rectify
     def present(presenter, options = {})
       presenter_type = options.fetch(:for) { :template }
 
-      presenter.for_controller(self)
+      presenter.attach_controller(self)
       rectify_presenters[presenter_type] = presenter
     end
 

data/lib/rectify/errors.rb

@@ -0,0 +1,11 @@
+module Rectify
+  class UnableToComposeQueries < StandardError
+    def initialize(query, other)
+      super(
+        "Unable to composite queries #{query.class.name} and " \
+        "#{other.class.name}. You cannot compose queries where #query " \
+        "returns an ActiveRecord::Relation in one and an array in the other."
+      )
+    end
+  end
+end

data/lib/rectify/null_query.rb

@@ -0,0 +1,11 @@
+module Rectify
+  class NullQuery < Query
+    def merge(query)
+      query
+    end
+
+    def query
+      []
+    end
+  end
+end

data/lib/rectify/presenter.rb

@@ -2,8 +2,9 @@ module Rectify
   class Presenter
     include Virtus.model
 
-    def for_controller(controller)
+    def attach_controller(controller)
       @controller = controller
+      self
     end
 
     def method_missing(method_name, *args, &block)

data/lib/rectify/query.rb

@@ -0,0 +1,65 @@
+module Rectify
+  class Query
+    def self.merge(*queries)
+      queries.reduce(NullQuery.new) { |a, e| a.merge(e) }
+    end
+
+    def initialize(scope = ActiveRecord::NullRelation)
+      @scope = scope
+    end
+
+    def query
+      @scope
+    end
+
+    def |(other)
+      if relation? && other.relation?
+        Rectify::Query.new(cached_query.merge(other.cached_query))
+      elsif eager? && other.eager?
+        Rectify::Query.new(cached_query | other.cached_query)
+      else
+        fail UnableToComposeQueries.new(self, other)
+      end
+    end
+
+    alias_method :merge, :|
+
+    def count
+      cached_query.count
+    end
+
+    def first
+      cached_query.first
+    end
+
+    def each(&block)
+      cached_query.each(&block)
+    end
+
+    def exists?
+      return cached_query.exists? if relation?
+
+      cached_query.present?
+    end
+
+    def none?
+      !exists?
+    end
+
+    def to_a
+      cached_query.to_a
+    end
+
+    def relation?
+      cached_query.is_a?(ActiveRecord::Relation)
+    end
+
+    def eager?
+      cached_query.is_a?(Array)
+    end
+
+    def cached_query
+      @cached_query ||= query
+    end
+  end
+end

data/lib/rectify/rspec/database_reporter/display.rb

@@ -0,0 +1,62 @@
+module Rectify
+  module RSpec
+    class DatabaseReporter
+      class Display
+        def initialize(query_stats)
+          @query_stats = query_stats
+        end
+
+        def render
+          return if query_stats.empty?
+
+          header
+          rows
+          summary
+        end
+
+        private
+
+        attr_reader :query_stats
+
+        def target_length
+          query_stats.longest_target
+        end
+
+        def header
+          puts ""
+          puts headers
+          puts "-" * headers.length
+        end
+
+        def headers
+          target_header  = "Target".ljust(target_length)
+          type_header    = "Type".ljust(10)
+          queries_header = "Queries".rjust(7)
+          time_header    = "Time (s)".rjust(7)
+
+          "#{target_header} | " \
+          "#{type_header} | " \
+          "#{queries_header} | " \
+          "#{time_header}"
+        end
+
+        def rows
+          query_stats.each do |target, type, count, time|
+            puts(
+              "#{target.ljust(target_length)} | " \
+              "#{type.to_s.ljust(10)} | " \
+              "#{count.to_s.rjust(7)} | " \
+              "#{time.to_s.rjust(7)}"
+            )
+          end
+        end
+
+        def summary
+          puts ""
+          puts "Database Queries: #{query_stats.total_queries} "\
+               "in #{query_stats.total_time}s"
+        end
+      end
+    end
+  end
+end

data/lib/rectify/rspec/database_reporter/query_info.rb

@@ -0,0 +1,46 @@
+module Rectify
+  module RSpec
+    class DatabaseReporter
+      class QueryInfo
+        def initialize(example, start, finish, query)
+          @example = example
+          @start   = start
+          @finish  = finish
+          @query   = query
+        end
+
+        def target
+          return described_class.name if described_class
+
+          root_example_group_description
+        end
+
+        def time
+          finish.to_f - start.to_f
+        end
+
+        def type
+          return example.metadata[:type] unless described_class
+
+          described_class <= Rectify::Query ? :query : :unit
+        end
+
+        def ignore?
+          SQL_TO_IGNORE.match(query[:sql]) || example.blank?
+        end
+
+        private
+
+        attr_reader :example, :start, :finish, :query
+
+        def described_class
+          example.metadata[:described_class]
+        end
+
+        def root_example_group_description
+          example.example_group.parent_groups.last.description
+        end
+      end
+    end
+  end
+end

data/lib/rectify/rspec/database_reporter/query_stats.rb

@@ -0,0 +1,51 @@
+module Rectify
+  module RSpec
+    class DatabaseReporter
+      class QueryStats
+        def initialize
+          @stats = Hash.new { |h, k| h[k] = [] }
+        end
+
+        def add(example, start, finish, query)
+          info = QueryInfo.new(example, start, finish, query)
+          return if info.ignore?
+
+          stats[info.target] << info
+        end
+
+        def each
+          stats.sort.each do |target, infos|
+            yield(
+              target,
+              infos.first.type,
+              infos.count,
+              infos.sum(&:time).round(5)
+            )
+          end
+        end
+
+        def total_queries
+          stats.values.flatten.count
+        end
+
+        def total_time
+          stats.values.flatten.sum(&:time).round(5)
+        end
+
+        def longest_target
+          return 0 if stats.empty?
+
+          stats.keys.max_by(&:length).length
+        end
+
+        def empty?
+          stats.empty?
+        end
+
+        private
+
+        attr_reader :stats
+      end
+    end
+  end
+end

data/lib/rectify/rspec/database_reporter/reporter.rb

@@ -0,0 +1,59 @@
+module Rectify
+  module RSpec
+    class DatabaseReporter
+      SQL_TO_IGNORE = /
+        pg_table|
+        pg_attribute|
+        pg_namespace|
+        current_database|
+        information_schema|
+        sqlite_master|
+        ^TRUNCATE TABLE|
+        ^ALTER TABLE|
+        ^BEGIN|
+        ^COMMIT|
+        ^ROLLBACK|
+        ^RELEASE|
+        ^SAVEPOINT|
+        ^SHOW|
+        ^PRAGMA
+      /xi
+
+      def self.enable
+        ::RSpec.configure do |config|
+          config.reporter.register_listener(
+            Reporter.new,
+            :start,
+            :example_started,
+            :start_dump
+          )
+        end
+      end
+
+      class Reporter
+        def initialize
+          @query_stats = QueryStats.new
+        end
+
+        def start(_)
+          ActiveSupport::Notifications
+            .subscribe("sql.active_record") do |_, start, finish, _, query|
+              query_stats.add(current_example, start, finish, query)
+            end
+        end
+
+        def example_started(notification)
+          @current_example = notification.example
+        end
+
+        def start_dump(_)
+          Display.new(query_stats).render
+        end
+
+        private
+
+        attr_reader :query_stats, :current_example
+      end
+    end
+  end
+end

data/lib/rectify/rspec/helpers.rb

@@ -0,0 +1,10 @@
+module Rectify
+  module RSpec
+    module Helpers
+      def stub_query(query_class, options = {})
+        results = options.fetch(:results, [])
+        allow(query_class).to receive(:new) { StubQuery.new(results) }
+      end
+    end
+  end
+end

data/lib/rectify/rspec/matchers.rb

@@ -0,0 +1,30 @@
+require "rspec/expectations"
+
+RSpec::Matchers.define :make_database_queries_of do |expected|
+  supports_block_expectations
+
+  queries = []
+
+  match do |proc|
+    ActiveSupport::Notifications
+      .subscribe("sql.active_record") do |_, _, _, _, query|
+        sql = query[:sql]
+
+        unless Rectify::RSpec::DatabaseReporter::SQL_TO_IGNORE.match(sql)
+          queries << sql
+        end
+      end
+
+    proc.call
+
+    queries.size == expected
+  end
+
+  failure_message do |_|
+    all_queries = queries.join("\n")
+
+    "expected the number of queries to be #{expected} " \
+    "but there were #{queries.size}.\n\n" \
+    "Here are the queries that were made:\n\n#{all_queries}"
+  end
+end

data/lib/rectify/rspec/stub_form.rb

@@ -0,0 +1,25 @@
+module Rectify
+  class StubForm
+    attr_accessor :attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def method_missing(method_name, *args, &block)
+      if attributes.key?(method_name)
+        attributes[method_name]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private = false)
+      attributes.key?(method_name)
+    end
+  end
+end

data/lib/rectify/rspec/stub_query.rb

@@ -0,0 +1,13 @@
+module Rectify
+  module RSpec
+    class StubQuery < Query
+      def initialize(results)
+        @results = Array(results)
+      end
+
+      def query
+        @results
+      end
+    end
+  end
+end

data/lib/rectify/rspec.rb

@@ -0,0 +1,9 @@
+require "rectify/rspec/stub_query"
+require "rectify/rspec/stub_form"
+require "rectify/rspec/helpers"
+require "rectify/rspec/matchers"
+
+require "rectify/rspec/database_reporter/display"
+require "rectify/rspec/database_reporter/query_info"
+require "rectify/rspec/database_reporter/query_stats"
+require "rectify/rspec/database_reporter/reporter"

data/lib/rectify/sql_query.rb

@@ -0,0 +1,7 @@
+module Rectify
+  module SqlQuery
+    def query
+      model.find_by_sql([sql, params])
+    end
+  end
+end

data/lib/rectify/version.rb

@@ -1,3 +1,3 @@
 module Rectify
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/rectify.rb

@@ -1,3 +1,5 @@
+require "bundler/setup"
+
 require "virtus"
 require "wisper"
 require "active_support/core_ext/hash"
@@ -7,6 +9,9 @@ require "active_record"
 require "rectify/version"
 require "rectify/form"
 require "rectify/command"
-require "rectify/save_command"
 require "rectify/presenter"
+require "rectify/query"
+require "rectify/null_query"
+require "rectify/sql_query"
 require "rectify/controller_helpers"
+require "rectify/errors"

data/readme.md

@@ -1,6 +1,7 @@
 # Rectify
 
 [![Code Climate](https://codeclimate.com/github/andypike/rectify/badges/gpa.svg)](https://codeclimate.com/github/andypike/rectify)
+[![Build Status](https://travis-ci.org/andypike/rectify.svg?branch=master)](https://travis-ci.org/andypike/rectify)
 
 Rectify is a gem that provides some lightweight classes that will make it easier
 to build Rails applications in a more maintainable way. It's built on top of
@@ -28,6 +29,7 @@ Currently, Rectify consists of the following concepts:
 * [Form Objects](#form-objects)
 * [Commands](#commands)
 * [Presenters](#presenters)
+* [Query Objects](#query-objects)
 
 You can use these separately or together to improve the structure of your Rails
 applications.
@@ -38,15 +40,21 @@ views are filled with too much logic. The opinion of Rectify is that these
 places are incorrect and that your models in particular are doing too much.
 
 Rectify's opinion is that controllers should just be concerned with HTTP related
-things and models should just be concerned with data access. The problem then
-becomes, how and where do you place validations and other business logic.
+things and models should just be concerned with data relationships. The problem
+then becomes, how and where do you place validations, queries and other business
+logic?
 
-Using Rectify, the Form Objects contain validations and represent the data input
+Using Rectify, Form Objects contain validations and represent the data input
 of your system. Commands then take a Form Object (as well as other data) and
-perform a single action which is invoked by a controller. Presenters contain the
-presentation logic in a way that is easily testable and keeps your views as
+perform a single action which is invoked by a controller. Query objects
+encapsulate a single database query (and any logic it needs). Presenters contain
+the presentation logic in a way that is easily testable and keeps your views as
 clean as possible.
 
+Rectify is designed to be very lightweight and allows you to use some or all of
+it's components. We also advise to use these components where they make sense
+not just blindly everywhere. More on that later.
+
 Here's an example controller that shows details about a user and also allows a
 user to register an account. This creates a user, sends some emails, does some
 special auditing and integrates with a third party system:
@@ -81,11 +89,12 @@ business logic of registering a new account. The controller is clean and
 business logic now has a natural home:
 
 ```
-HTTP           => Controller  (redirecting, rendering, etc)
-Data Input     => Form Object (validation, acceptable input)
-Business Logic => Command     (logic for a specific use case)
-Data Access    => Model       (relationships, queries)
-View Logic     => Presenter   (formatting data)
+HTTP             => Controller   (redirecting, rendering, etc)
+Data Input       => Form Object  (validation, acceptable input)
+Business Logic   => Command      (logic for a specific use case)
+Data Persistence => Model        (relationships between models)
+Data Access      => Query Object (database queries)
+View Logic       => Presenter    (formatting data)
 ```
 
 The next sections will give further details about using Form Objects, Commands
@@ -503,7 +512,7 @@ provide a more object oriented approach to the problem.
 To create a Presenter just derive off of `Rectify::Presenter`, add attributes as
 you do for Form Objects using [Virtus](https://github.com/solnic/virtus)
 `attribute` declaration. Inside a Presenter you have access to all view helper
-methods so it's easy to move the presetation logic here:
+methods so it's easy to move the presentation logic here:
 
 ```ruby
 class UserDetailsPresenter < Rectify::Presenter
@@ -526,12 +535,12 @@ class UsersController < ApplicationController
   def show
     user = User.find(params[:id])
 
-    @presenter = UserDetailsPresenter.new(:user => user).for_controller(self)
+    @presenter = UserDetailsPresenter.new(:user => user).attach_controller(self)
   end
 end
 ```
 
-You need to call `#for_controller` and pass it a controller instance which will
+You need to call `#attach_controller` and pass it a controller instance which will
 allow it access to the view helpers. You can then use the Presenter in your
 views as you would expect:
 
@@ -602,7 +611,7 @@ class UsersController < ApplicationController
   def other_action
     user = User.find(params[:id])
 
-    @presenter = UserDetailsPresenter.new(:user => user).for_controller(self)
+    @presenter = UserDetailsPresenter.new(:user => user).attach_controller(self)
     @presenter.user = User.first
   end
 end
@@ -669,13 +678,267 @@ user.each do |u|
 end
 ```
 
+## Query Objects
+
+The final main component to Rectify is the Query Object. It's role is to
+encapsulate a single database query and any logic that it query needs to
+operate. It still uses ActiveRecord but adds some very light sugar on the top to
+make this style of architecture easier. This helps to keep your model classes
+lean and gives a natural home to this code.
+
+To create a query object, you create a new class and derive off of
+`Rectify::Query`. The only thing you need to do is to implement the
+`#query` method and return an `ActiveRecord::Relation` object from it:
+
+```ruby
+class ActiveUsers < Rectify::Query
+  def query
+    User.where(:active => true)
+  end
+end
+```
+
+To use this object, you just instantiate it and then use one of the following
+methods to make use of it:
+
+```ruby
+ActiveUsers.new.count   # => Returns the number of records
+ActiveUsers.new.first   # => Returns the first record
+ActiveUsers.new.exists? # => Returns true if there are any records, else false
+ActiveUsers.new.none?   # => Returns true if there are no records, else false
+ActiveUsers.new.to_a    # => Execute the query and returns the resulting objects
+ActiveUsers.new.each do |user| # => Iterates over each result
+  puts user.name
+end
+```
+
+### Passing data to query objects
+
+Passing data that your queries need to operate is best done via the constructor:
+
+```ruby
+class UsersOlderThan < Rectify::Query
+  def initialize(age)
+    @age = age
+  end
+
+  def query
+    User.where("age > ?", @age)
+  end
+end
+
+UsersOlderThan.new(25).count # => Returns the number of users over 25 years old
+```
+
+Sometimes your queries will need to do a little work with the provided data
+before they can use it. Having your query encapsulated in an object makes this
+easy and maintainable (here's a trivial example):
+
+```ruby
+class UsersWithBlacklistedEmail < Rectify::Query
+  def initialize(blacklist)
+    @blacklist = blacklist
+  end
+
+  def query
+    User.where(:email => blacklisted_emails)
+  end
+
+  private
+
+  def blacklisted_emails
+    @blacklist.map { |b| b.email.strip.downcase }
+  end
+end
+```
+
+### Composition
+
+One of this great features of ActiveRecord is the ability to easily compose
+queries together in a simple way which helps reusability. Rectify Query Objects
+can also be combined to created composed queries using the `|` operator as we
+use in Ruby for Set Union. Here's how it looks:
+
+```ruby
+active_users_over_20 = ActiveUsers.new | UsersOlderThan.new(20)
+
+active_users_over_20.count # => Returns number of active users over 20 years old
+```
+
+You can union many queries in this manner which will result in another
+`Rectify::Query` object that you can use just like any other. This results in a
+single database query.
+
+As an alternative you can also use the `#merge` method which is simply an alias
+of the `|` operator:
+
+```ruby
+active_users_over_20 = ActiveUsers.new.merge(UsersOlderThan.new(20))
+
+active_users_over_20.count # => Returns number of active users over 20 years old
+```
+
+If you have a long list of queries to compose, Rectify also comes with the class
+method `.merge` which takes multiple queries and combines them for you as if you
+used `|` (or `#merge`) on them all:
+
+```ruby
+active_users_over_20 = Rectify::Query.merge(
+  ActiveUsers.new,
+  UsersOlderThan.new(20)
+)
+
+active_users_over_20.count # => Returns number of active users over 20 years old
+```
+
+If you don't those options for composing queries then the final option would be
+to pass in a query object to another in it's constructor and use it as the base
+scope:
+
+```ruby
+class UsersOlderThan < Rectify::Query
+  def initialize(age, scope = AllUsers.new)
+    @age   = age
+    @scope = scope
+  end
+
+  def query
+    @scope.query.where("age > ?", @age)
+  end
+end
+
+UsersOlderThan.new(20, ActiveUsers.new).count
+```
+
+### Leveraging your database
+
+Using `ActiveRecord::Relation` is a great way to construct your database queries
+but sometimes you need to to use features of your database that aren't supported
+by ActiveRecord directly. These are usually database specific and can greatly
+improve your query efficiency. When that happens, you will need to write some
+raw SQL. Rectify Query Objects allow for this. In addition to your `#query`
+method returning an `ActiveRecord::Relation` you can also return an array of
+objects. This means you can run raw SQL using
+`ActiveRecord::Querying#find_by_sql`:
+
+```ruby
+class UsersOverUsingSql < Rectify::Query
+  def initialize(age)
+    @age = age
+  end
+
+  def query
+    User.find_by_sql([
+      "SELECT * FROM users WHERE age > :age ORDER BY age ASC", { :age => @age }
+    ])
+  end
+end
+```
+
+When you do this, the normal `Rectify::Query` methods are available but they
+operate on the returned array rather than on the `ActiveRecord::Relation`. This
+includes composition using the `|` operator but you can't compose an
+`ActiveRecord::Relation` query object with one that returns an array of objects
+from its `#query` method. You can compose two queries where both return arrays
+but be aware that this will query the database for each query object and then
+perform a Ruby array set union on the results. This might not be the most
+efficient way to get the results so only use this when you are sure it's the
+right thing to do.
+
+The above example is fine for short SQL statements but if you are using raw SQL,
+they will probably be much longer than a single line. Rectify provides a small
+module that you can include to makes your query objects cleaner:
+
+```ruby
+class UsersOverUsingSql < Rectify::Query
+  include Rectify::SqlQuery
+
+  def initialize(age)
+    @age = age
+  end
+
+  def model
+    User
+  end
+
+  def sql
+    <<-SQL.strip_heredoc
+      SELECT *
+      FROM users
+      WHERE age > :age
+      ORDER BY age ASC
+    SQL
+  end
+
+  def params
+    { :age => @age }
+  end
+end
+```
+
+Just include `Rectify::SqlQuery` in your query object and then supply the a
+`model` method that returns the model of the returned objects. A
+`params` method that returns a hash containing named parameters that the SQL
+statement requires. Lastly, you must supply a `sql` method that returns the raw
+SQL. We recommend using a heredoc which makes the SQL much cleaner and easier
+to read. Parameters use the ActiveRecord standard symbol notation as shown above
+with the `:age` parameter.
+
+### Stubbing Query Objects in tests
+
+Now that you have your queries nicely encapsulated, it's now easier with a clear
+division of responsibility to improve how you use the database within your
+tests. You should unit test your Query Objects to ensure they return the correct
+data from a know database state.
+
+What you can now do it stub out these database calls when you use them in other
+classes. This improves your test code in a couple of ways:
+
+1. You need less database setup code within your tests. Normally you might use
+something like factory_girl to create records in your database and then when
+your tests run they query this set of data. Stubbing the queries within your
+tests can reduce this complexity.
+2. Fewer database queries running and less factory usage means that your tests
+3. are doing less work and therefore will run a bit faster.
+
+In Rectify, we provide the RSpec helper method `stub_query` that will make
+stubbing Query Objects easy:
+
+```ruby
+# inside spec/rails_helper.rb
+
+require "rectify/rspec"
+
+RSpec.configure do |config|
+  # snip ...
+
+  config.include Rectify::RSpec::Helpers
+end
+
+# within a spec:
+
+it "returns the number of users" do
+  stub_query(UsersOlderThan, :results => [User.new, User.new])
+
+  expect(subject.awesome_method).to eq(2)
+end
+```
+
+As a convenience `:results` accepts either an array of objects or a single
+instance:
+
+```ruby
+stub_query(UsersOlderThan, :results => [User.new, User.new])
+stub_query(UsersOlderThan, :results => User.new)
+```
+
 ## Where do I put my files?
 
-The next inevitable question is "Where do I put my Forms, Commands and
-Presenters?". You could create `forms`, `commands` and `presenters` folders and
-follow the Rails Way. Rectify suggests grouping your classes by feature rather
-than by pattern. For example, create a folder called `core` (this can be
-anything) and within that, create a folder for each broad feature of your
+The next inevitable question is "Where do I put my Forms, Commands, Queries and
+Presenters?". You could create `forms`, `commands`, `queries` and `presenters`
+folders and follow the Rails Way. Rectify suggests grouping your classes by
+feature rather than by pattern. For example, create a folder called `core` (this
+can be anything) and within that, create a folder for each broad feature of your
 application. Something like the following:
 
 ```
@@ -693,7 +956,8 @@ application. Something like the following:
 ```
 
 Then you would place your classes in the appropriate feature folder. If you
-follow this pattern remember to namespace your classes with a matching module:
+follow this pattern remember to namespace your classes with a matching module
+which will allow Rails to load them:
 
 ```ruby
 # in app/core/billing/send_invoice.rb
@@ -708,6 +972,25 @@ end
 You don't need to alter your load path as everything in the `app` folder is
 loaded automatically.
 
+As stated above, if you prefer not to use this method of organizing your code
+then that is totally fine. Just create folders under `app` for the things in
+Rectify that you use:
+
+```
+.
+└── app
+    ├── commands
+    ├── controllers
+    ├── forms
+    ├── models
+    ├── presenters
+    ├── queries
+    └── views
+```
+
+You don't need to make any configuration changes for your preferred folder
+structure, just use whichever you feel most comfortable with.
+
 ## Trade offs
 
 This style of Rails architecture is not a silver bullet for all projects. If
@@ -721,12 +1004,21 @@ whole system in your head. Personally I would prefer that as maintaining it will
 be easier as all code around a specific user task is on one place.
 
 Before you use these methods in your project, consider the trade off and use
-these strategies where they make sense for you and your project.
+these strategies where they make sense for you and your project. It maybe most
+pragmatic to use a mixture of the classic Rails Way and the Rectify approach
+depending on the complexity of different areas of your application.
+
+## Developing Rectify
 
-## What's next?
+Some tests (specifically for Query objects) we need access to a database that
+ActiveRecord can connect to. We use SQLite for this at present. When you run the
+specs with `bundle exec rspec`, the database will be created for you.
 
-We stated above that the models should be responsible for data access. We
-may introduce a nice way to keep using the power of ActiveRecord but in a way
-where your models don't end up as a big ball of queries. We're thinking about
-Query Objects and a nice way to do this and we're also thinking about a nicer
-way to use raw SQL.
+There are some Rake tasks to help with the management of this test database
+using normal(ish) commands from Rails:
+
+```
+rake db:migrate   # => Migrates the test database
+rake db:schema    # => Dumps database schema
+rake g:migration  # => Create a new migration file
+```

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rectify
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andy Pike
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-20 00:00:00.000000000 Z
+date: 2016-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -206,6 +206,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.1.2
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Build Rails apps in a more maintainable way
 email: andy@andypike.com
 executables: []
@@ -216,9 +244,21 @@ files:
 - lib/rectify.rb
 - lib/rectify/command.rb
 - lib/rectify/controller_helpers.rb
+- lib/rectify/errors.rb
 - lib/rectify/form.rb
+- lib/rectify/null_query.rb
 - lib/rectify/presenter.rb
-- lib/rectify/save_command.rb
+- lib/rectify/query.rb
+- lib/rectify/rspec.rb
+- lib/rectify/rspec/database_reporter/display.rb
+- lib/rectify/rspec/database_reporter/query_info.rb
+- lib/rectify/rspec/database_reporter/query_stats.rb
+- lib/rectify/rspec/database_reporter/reporter.rb
+- lib/rectify/rspec/helpers.rb
+- lib/rectify/rspec/matchers.rb
+- lib/rectify/rspec/stub_form.rb
+- lib/rectify/rspec/stub_query.rb
+- lib/rectify/sql_query.rb
 - lib/rectify/version.rb
 - readme.md
 homepage: https://github.com/andypike/rectify

data/lib/rectify/save_command.rb

@@ -1,21 +0,0 @@
-module Rectify
-  class SaveCommand < Command
-    def initialize(form, model)
-      @form  = form
-      @model = model
-    end
-
-    def call
-      return broadcast(:invalid) unless form.valid?
-
-      model.attributes = form.attributes
-      model.save!
-
-      broadcast(:ok)
-    end
-
-    private
-
-    attr_reader :form, :model
-  end
-end