tphases 0.1.2 → 0.2.0

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+script: bundle exec rspec spec
+notifications:
+  email: false

data/README.md

@@ -1,5 +1,8 @@
 # TPhases
 
+[![Build Status](https://travis-ci.org/charleseff/tphases.png)](https://travis-ci.org/charleseff/tphases)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/charleseff/tphases)
+
 TPhases (Transactional Phases) is a support framework that helps you build your Rails request life cycles into read-only, write-only, and no-transaction-allowed phases.
 
 The way it accomplishes this is with the methods `TPhases.read_phase`, `TPhases.write_phase` and `TPhases.no_transactions_phase` which take blocks.  Here is a simple example inside of a controller action:
@@ -46,23 +49,38 @@ Somewhere in the initialization process of your app, call
 
 ## Usage
 
-### In production:
+### Environments
+
+#### In production:
 The `read_phase`, `write_phase`, and `no_transaction_phase` methods simply yield to the block given.
 
-### In development:
+#### In development:
 
-#### `read_phase`
+##### `read_phase`
 throws an exception if a database transaction is attempted within its block which is a write.  This is known as a "read transactional violation".
 
-#### `write_phase`
+##### `write_phase`
 throws an exception if a database transaction is attempted within its block which is a read.  This is a write transactional violation.
 
-#### `no_transactions_phase`
+##### `no_transactions_phase`
 throws an exception if any database transaction is attempted within its block.
 
-### In test:
+#### In test:
 If a transactional violation occurs in a TPhase, the code will continue to run, but the test will fail at the end citing the list of transactional violations that occurred.
 
+### Methods
+
+#### `ensure_no_transactions_on`
+Call `ensure_no_transactions_on` on controllers to prevent DB transactions within the views of controller actions.  e.g.:
+
+```ruby
+class BarsController < ApplicationController
+
+  ensure_no_transactions_on [:show,:update]
+end
+```
+
+
 ## Contributing
 
 1. Fork it

data/lib/tphases/config.rb

@@ -8,10 +8,16 @@ module TPhases
         yield config
       end
 
-      private
       # the config
+      # settings options are:
+      #
+      # - mode
+      # - collect_mode_failures_on - defaults to true, but can be turned off temporarily to disable failures on
+      #        transaction violations
+      #
       # sets default value `mode` value based on presence of Rails and environment type
       # the default setting is the safest, :pass_through, which means TPhases does nothing.
+      #
       def config
         @config ||= begin
 
@@ -32,7 +38,7 @@ module TPhases
             end
           end
 
-          Struct.new(:mode).new(default_mode)
+          Struct.new(:mode, :collect_mode_failures_on).new(default_mode, true)
         end
       end
 

data/lib/tphases/initialization.rb

@@ -5,6 +5,12 @@ module TPhases
     module ClassMethods
       # initiates TPhases.  Any overrides to config mode need to be made prior to running this.
       def initiate!
+        add_mode_methods!
+        add_rails_methods! if defined? Rails
+      end
+
+      private
+      def add_mode_methods!
         case config.mode
           when :pass_through
             require 'tphases/modes/pass_through_mode'
@@ -18,7 +24,6 @@ module TPhases
           else
             raise "TPhases mode must be one of :pass_through, :exceptions, or :collect, but instead is #{config.mode}"
         end
-
       end
 
     end

data/lib/tphases/modes/collect_mode.rb

@@ -1,5 +1,6 @@
 require 'tphases/transactional_violation'
 require 'tphases/modes/helpers/transactional_violations_helper'
+require 'tphases/modes/helpers/rails_helper'
 
 # the default 'test' mode, Collect Mode collects incidents of
 # immediately inside of a TPhase block if a transactional violation occurs
@@ -8,9 +9,11 @@ module TPhases
     module CollectMode
       extend ActiveSupport::Concern
       include Helpers::TransactionalViolationsHelper
+      include Helpers::RailsHelper if defined? Rails
 
       included do
         add_rspec_after! if defined?(RSpec)
+        add_cucumber_after! if defined?(Cucumber)
         @violations = []
       end
 
@@ -34,26 +37,49 @@ module TPhases
         # adds an after block for all rspec tests that cause them to fail if any transactional violations are present
         def add_rspec_after!
           RSpec.configure do |config|
-            config.after(:each) do
-              begin
-                unless TPhases.violations.empty?
-                  #fail "This spec had #{TPhases.violations.count} transactional violations: \n\t#{TPhases.violations.map(&:inspect).join("\n\t")}"
-                  fail <<-FAILURE_MESSAGE
-                    This spec had #{TPhases.violations.count} transactional violations:
-                      #{TPhases.violations.each_with_index.map do |violation,index|
-                    "#{index}: Violation Type: #{violation[:type]},\nSQL: #{violation[:sql]}\nCall Stack:\n\t#{violation[:call_stack].join("\n\t")}"
-                  end.join("\n*********************************************************\n")}
-                  end
-                  FAILURE_MESSAGE
+            config.after(:each, &after_test_fail_if_violations_proc)
+          end
+        end
+
+        def add_cucumber_after!
+          # todo: get me working
+          #require 'cucumber/rb_support/rb_dsl'
+          #Cucumber::RbSupport::RbDsl.register_rb_hook('after', [], after_test_fail_if_violations_proc)
+        end
+
+        # fails if there were any transactional violations
+        def after_test_fail_if_violations_proc
+          Proc.new do
+            begin
+              if TPhases.config.collect_mode_failures_on && !TPhases.violations.empty?
+
+                fail_message = "This spec had #{TPhases.violations.count} transactional violations:\n"
+                TPhases.violations.each_with_index.map do |violation, index|
+                  fail_message << "*"*50 + "\n"
+                  fail_message << "Violation ##{index+1}, type: #{violation[:type]}\n"
+                  fail_message << "SQL: #{violation[:sql]}\n"
+                  fail_message << "Call Stack: \n\t\t#{TPhases.cleaned_call_stack(violation[:call_stack]).join("\n\t\t")}\n"
                 end
-              ensure
-                # reset violations list:
-                TPhases.violations = []
+
+                fail fail_message
               end
+            ensure
+              TPhases.violations = [] # reset violations list
             end
           end
+
         end
 
+        public
+        # taken from https://github.com/rails/rails/blob/77977f34a5a4ea899f59e31ad869b582285fa5c1/actionpack/lib/action_dispatch/middleware/show_exceptions.rb#L148 :
+        # shows a cleaned stack for Rails apps by default
+        def cleaned_call_stack(call_stack)
+          defined?(Rails) && Rails.respond_to?(:backtrace_cleaner) ?
+            Rails.backtrace_cleaner.clean(call_stack, :silent) :
+            call_stack
+        end
+
+
       end
     end
   end

data/lib/tphases/modes/exceptions_mode.rb

@@ -1,5 +1,6 @@
 require 'tphases/transactional_violation'
 require 'tphases/modes/helpers/transactional_violations_helper'
+require 'tphases/modes/helpers/rails_helper'
 
 # the default 'development' mode, Exceptions Mode means that an exception will be raised
 # immediately inside of a TPhase block if a transactional violation occurs
@@ -8,6 +9,7 @@ module TPhases
     module ExceptionsMode
       extend ActiveSupport::Concern
       include Helpers::TransactionalViolationsHelper
+      include Helpers::RailsHelper if defined? Rails
 
       module ClassMethods
         private

data/lib/tphases/modes/helpers/rails_helper.rb

@@ -0,0 +1,41 @@
+module TPhases::Modes
+  module Helpers
+    module RailsHelper
+      extend ActiveSupport::Concern
+      module ClassMethods
+        def add_rails_methods!
+          add_render_alias_method_chain!
+
+          require 'tphases/rails/no_transactions_in_controller'
+          ActionController::Base.send :include, TPhases::Rails::NoTransactionsInController
+        end
+
+        private
+        def add_render_alias_method_chain!
+          unless Gem.loaded_specs.values.map { |value| value.full_gem_path }.any? { |n| n.include? "actionpack-3.0." }
+            raise "TPhases currently expects Rails version 3.0.* for patching ActionView template."
+          end
+
+          ActionView::Template.class_eval do
+
+            def render_with_tphases_no_transactions(view, locals, &block)
+              controller_class = view.controller.class
+              if controller_class.class_variable_defined?(:@@no_transaction_actions) &&
+                  controller_class.class_variable_get(:@@no_transaction_actions).include?(view.action_name.to_sym)
+                TPhases.no_transactions_phase do
+                  render_without_tphases_no_transactions(view, locals, &block)
+                end
+              else
+                render_without_tphases_no_transactions(view, locals, &block)
+              end
+            end
+
+            alias_method_chain :render, :tphases_no_transactions
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/tphases/modes/helpers/transactional_violations_helper.rb

@@ -13,121 +13,75 @@ module TPhases
 
         included do
           define_phase_methods!
+
+          # used to keep track of nested phases.  a nested phase overrides any prior phase.
+          @phase_stack = []
         end
 
-        private
         module ClassMethods
 
-          # if version of activesupport is 3.2.1, it has the subscribed method.  else, it doesn't
           def define_phase_methods!
-            if ActiveSupport::VERSION::MAJOR > 3
-              define_phase_methods_with_subscribed_method!
-            elsif ActiveSupport::VERSION::MAJOR == 3
-              if ActiveSupport::VERSION::MINOR > 2
-                define_phase_methods_with_subscribed_method!
-              elsif ActiveSupport::VERSION::MINOR == 2
-                if ActiveSupport::VERSION::TINY >= 1
-                  define_phase_methods_with_subscribed_method!
-                else
-                  define_phase_methods_without_subscribed_method!
+            %w{read write no_transactions}.each do |phase_type|
+              define_singleton_method(:"#{phase_type}_phase") do |&block|
+                phase = Phase.new
+                @phase_stack << phase
+                begin
+                  subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |name, date, date2, sha, args|
+                    next unless @phase_stack.last == phase
+                    if send(:"#{phase_type}_violation?", args[:sql])
+                      send(:"#{phase_type}_violation_action", args[:sql], caller)
+                    end
+
+                  end
+                  block.call
+                ensure
+                  ActiveSupport::Notifications.unsubscribe(subscriber)
+                  @phase_stack.pop
                 end
-              else
-                define_phase_methods_without_subscribed_method!
               end
-            else
-              define_phase_methods_without_subscribed_method!
-            end
-          end
-
-          # adds methods using the subscribed method
-          def define_phase_methods_with_subscribed_method!
-            define_singleton_method(:read_phase) do |&block|
-              ActiveSupport::Notifications.subscribed(read_phase_subscription_callback, "sql.active_record", &block)
-            end
-
-            define_singleton_method(:write_phase) do |&block|
-              ActiveSupport::Notifications.subscribed(write_phase_subscription_callback, "sql.active_record", &block)
-            end
-
-            define_singleton_method(:no_transactions_phase) do |&block|
-              ActiveSupport::Notifications.subscribed(no_transactions_phase_subscription_callback, "sql.active_record", &block)
             end
           end
 
-          def define_phase_methods_without_subscribed_method!
-            define_singleton_method(:read_phase) do |&block|
-              begin
-                subscriber = ActiveSupport::Notifications.subscribe("sql.active_record", &read_phase_subscription_callback)
-                block.call
-              ensure
-                ActiveSupport::Notifications.unsubscribe(subscriber)
-              end
-            end
-
-            define_singleton_method(:write_phase) do |&block|
-              begin
-                subscriber = ActiveSupport::Notifications.subscribe("sql.active_record", &write_phase_subscription_callback)
-                block.call
-              ensure
-                ActiveSupport::Notifications.unsubscribe(subscriber)
-              end
-            end
+          private
+          READ_QUERIES            = %w{show select describe}
+          WRITE_QUERIES           = %w{update commit insert delete}
+          RAILS_IGNORABLE_QUERIES = %w{describe}
 
-            define_singleton_method(:no_transactions_phase) do |&block|
-              begin
-                subscriber = ActiveSupport::Notifications.subscribe("sql.active_record", &no_transactions_phase_subscription_callback)
-                block.call
-              ensure
-                ActiveSupport::Notifications.unsubscribe(subscriber)
-              end
-            end
+          def rails_ignorable_read_queries
+            @rails_ignorable_read_queries ||= READ_QUERIES - RAILS_IGNORABLE_QUERIES
           end
 
-          # the set of blocks that run when an ActiveSupport notification is fired on sql.active_record
-          # each call *_violation_action methods which are defined in the implementing module
-
-          def write_phase_subscription_callback
-            Proc.new do |name, date, date2, sha, args|
-              if write_transactional_violation?(args[:sql])
-                write_violation_action(args[:sql], caller)
-              end
-            end
+          # determines if this query is a read transactional violation (if it is anything besides a read)
+          def read_violation?(sql)
+            WRITE_QUERIES.include?(first_word(sql))
           end
 
-          def read_phase_subscription_callback
-            Proc.new do |name, date, date2, sha, args|
-              if read_transactional_violation?(args[:sql])
-                read_violation_action(args[:sql], caller)
-              end
-            end
+          # determines if this query is a write transactional violation (if it is anything besides a write)
+          def write_violation?(sql)
+            query_types = (Object.const_defined? :Rails) ? rails_ignorable_read_queries : READ_QUERIES
+            query_types.include?(first_word(sql))
           end
 
-          def no_transactions_phase_subscription_callback
-            Proc.new do |name, date, date2, sha, args|
-              no_transactions_violation_action(args[:sql], caller)
+          # violation unless it's Rails and we are running an ignorable query
+          def no_transactions_violation?(sql)
+            if Object.const_defined? :Rails
+              !RAILS_IGNORABLE_QUERIES.include?(first_word(sql))
+            else
+              true
             end
           end
 
-          READ_QUERIES  = %w{update commit insert delete}
-          WRITE_QUERIES = %w{show select}
-
-          # determines if this query is a read transactional violation (if it is anything besides a read)
-          def read_transactional_violation?(sql)
-            READ_QUERIES.include?(first_word(sql))
-          end
-
-          # determines if this query is a write transactional violation (if it is anything besides a write)
-          def write_transactional_violation?(sql)
-            WRITE_QUERIES.include?(first_word(sql))
-          end
-
           def first_word(str)
             str.split(' ').first.downcase
           end
 
         end
 
+        # simple class to represent a phase on the stack of phases.  Used to determine which phase is active
+        class Phase;
+        end
+
       end
     end
   end
-end
+end

data/lib/tphases/modes/pass_through_mode.rb

@@ -16,6 +16,12 @@ module TPhases
         def no_transactions_phase
           yield
         end
+
+        private
+        def add_rails_methods!
+          require 'tphases/rails/no_transactions_in_controller_pass_through'
+          ActionController::Base.send :include, TPhases::Rails::NoTransactionsInControllerPassThrough
+        end
       end
     end
   end

data/lib/tphases/rails/no_transactions_in_controller.rb

@@ -0,0 +1,15 @@
+module TPhases
+  module Rails
+    module NoTransactionsInController
+      extend ActiveSupport::Concern
+      module ClassMethods
+
+        def ensure_no_transactions_on(actions)
+          class_variable_set(:@@no_transaction_actions, actions)
+        end
+
+      end
+    end
+
+  end
+end

data/lib/tphases/rails/no_transactions_in_controller_pass_through.rb

@@ -0,0 +1,12 @@
+module TPhases
+  module Rails
+    module NoTransactionsInControllerPassThrough
+      extend ActiveSupport::Concern
+      module ClassMethods
+        def ensure_no_transactions_on(actions)
+          # do nothing
+        end
+      end
+    end
+  end
+end

data/lib/tphases/version.rb

@@ -1,3 +1,3 @@
 module Tphases
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/lib/tphases/modes/exceptions_mode_spec.rb

@@ -58,4 +58,45 @@ describe TPhases::Modes::ExceptionsMode do
 
     end
   end
+
+  describe "nested phases" do
+    context "read_phase inside of a no_transactions_phase" do
+      it "should allow read transactions" do
+        expect {
+          subject.no_transactions_phase do
+            subject.read_phase do
+              ActiveRecord::Base.connection.select_all(read_sql)
+            end
+          end
+        }.to_not raise_error
+
+      end
+    end
+
+    context "no_transactions_phase inside a read_phase" do
+      it "should disallow read transactions" do
+        expect {
+          subject.read_phase do
+            subject.no_transactions_phase do
+              ActiveRecord::Base.connection.select_all(read_sql)
+            end
+          end
+        }.to raise_error(ActiveRecord::StatementInvalid, "TransactionalViolation: #{read_sql} ran inside of a 'no_transactions_phase' block.: #{read_sql}")
+
+
+      end
+    end
+
+    it "should have the right phase_stack sizes" do
+      subject.instance_variable_get("@phase_stack").should be_empty
+      subject.read_phase do
+        subject.instance_variable_get("@phase_stack").size.should == 1
+        subject.no_transactions_phase do
+          subject.instance_variable_get("@phase_stack").size.should == 2
+        end
+        subject.instance_variable_get("@phase_stack").size.should == 1
+      end
+      subject.instance_variable_get("@phase_stack").should be_empty
+    end
+  end
 end

data/spec/lib/tphases/modes/helpers/transactional_violations_helper_spec.rb

@@ -2,37 +2,67 @@ require 'spec_helper'
 require 'tphases/modes/helpers/transactional_violations_helper'
 
 describe TPhases::Modes::Helpers::TransactionalViolationsHelper do
-  describe TPhases::Modes::Helpers::TransactionalViolationsHelper do
-    subject { Module.new { include TPhases::Modes::Helpers::TransactionalViolationsHelper } }
+  subject { Module.new { include TPhases::Modes::Helpers::TransactionalViolationsHelper } }
 
-    let(:write_queries) {
-      [
-          "UPDATE `users` SET `email` = 'woifjwe@owiejf.com' WHERE `users`.`id` = 1",
-          "INSERT INTO tablename (col1, col2) VALUES('data1', 'data2' )",
-          "COMMIT",
-          "DELETE FROM example WHERE age='15'"
-      ]
-    }
-    let(:read_queries) {
-      [
-          "select * from foobar",
-          "show variables like 'version'"
-      ]
-    }
+  let(:write_queries) {
+    [
+        "UPDATE `users` SET `email` = 'woifjwe@owiejf.com' WHERE `users`.`id` = 1",
+        "INSERT INTO tablename (col1, col2) VALUES('data1', 'data2' )",
+        "COMMIT",
+        "DELETE FROM example WHERE age='15'"
+    ]
+  }
+  let(:read_queries) {
+    [
+        "select * from foobar",
+        "show variables like 'version'"
+    ]
+  }
 
-    describe "#read_transactional_violation?" do
-      it "should detect correctly" do
-        read_queries.each { |read_query| expect(subject.send(:read_transactional_violation?, read_query)).to eq(false) }
-        write_queries.each { |write_query| expect(subject.send(:read_transactional_violation?, write_query)).to eq(true) }
+  describe "#read_transactional_violation?" do
+    it "should detect correctly" do
+      read_queries.each { |read_query| expect(subject.send(:read_violation?, read_query)).to eq(false) }
+      write_queries.each { |write_query| expect(subject.send(:read_violation?, write_query)).to eq(true) }
+    end
+  end
+
+  describe "#write_violation?" do
+    it "should detect correctly" do
+      read_queries.each { |read_query| expect(subject.send(:write_violation?, read_query)).to be_true }
+      write_queries.each { |write_query| expect(subject.send(:write_violation?, write_query)).to be_false }
+    end
+
+    context "describe queries" do
+      context "when Rails is present" do
+        it "should detect correctly" do
+          Object.should_receive(:const_defined?).with(:Rails).and_return(true)
+          expect(subject.send(:write_violation?, "describe foo")).to be_false
+        end
+      end
+      context "when Rails is not present" do
+        it "should detect correctly" do
+          Object.should_receive(:const_defined?).with(:Rails).and_return(false)
+          expect(subject.send(:write_violation?, "describe foo")).to be_true
+        end
       end
     end
 
-    describe " #write_transactional_violation?" do
+  end
+
+  describe "#no_transactions_violation?" do
+    context "when Rails is present" do
       it "should detect correctly" do
-        read_queries.each { |read_query| expect(subject.send(:write_transactional_violation?, read_query)).to be_true }
-        write_queries.each { |write_query| expect(subject.send(:write_transactional_violation?, write_query)).to be_false }
+        Object.stub(:const_defined?).with(:Rails).and_return(true)
+        expect(subject.send(:no_transactions_violation?, "describe foo")).to be_false
+        expect(subject.send(:no_transactions_violation?, "select * from foo")).to be_true
+      end
+    end
+    context "when Rails is not present" do
+      it "should detect correctly" do
+        Object.stub(:const_defined?).with(:Rails).and_return(false)
+        expect(subject.send(:no_transactions_violation?, "describe foo")).to be_true
+        expect(subject.send(:no_transactions_violation?, "select * from foo")).to be_true
       end
     end
-
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tphases
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-03 00:00:00.000000000 Z
+date: 2012-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -117,6 +117,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -126,8 +127,11 @@ files:
 - lib/tphases/initialization.rb
 - lib/tphases/modes/collect_mode.rb
 - lib/tphases/modes/exceptions_mode.rb
+- lib/tphases/modes/helpers/rails_helper.rb
 - lib/tphases/modes/helpers/transactional_violations_helper.rb
 - lib/tphases/modes/pass_through_mode.rb
+- lib/tphases/rails/no_transactions_in_controller.rb
+- lib/tphases/rails/no_transactions_in_controller_pass_through.rb
 - lib/tphases/transactional_violation.rb
 - lib/tphases/version.rb
 - spec/fixtures/database.sqlite3