tphases 0.1.2

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+Gemfile.lock
+.idea
+
+spec/fixtures/database.sqlite3

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 tphases.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Charles Finkel
+
+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,72 @@
+# 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:
+
+```ruby
+class BarsController < ApplicationController
+
+  def update
+    TPhases.read_phase do
+      @bar = Bar.find(params[:id])
+    end
+    
+    TPhases.write_phase do
+      @bar.update_attributes(params[:bar])
+    end
+
+    TPhases.no_transactions_phase do
+      process(@bar)
+      redirect_to @bar
+    end
+  end
+end
+```
+
+** Currently supports ActiveRecord only.  Planned support includes Memcached, Redis, MongoDB, and more.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tphases'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tphases
+
+Somewhere in the initialization process of your app, call 
+
+    TPhases.initiate!
+
+## Usage
+
+### In production:
+The `read_phase`, `write_phase`, and `no_transaction_phase` methods simply yield to the block given.
+
+### In development:
+
+#### `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`
+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`
+throws an exception if any database transaction is attempted within its block.
+
+### 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.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/tphases/config.rb

@@ -0,0 +1,41 @@
+module TPhases
+  module Config
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # allow for configuration of TPhases
+      def configure(&block)
+        yield config
+      end
+
+      private
+      # the config
+      # 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
+
+          default_mode = begin
+            if defined? Rails
+              case Rails.env
+                when 'production', 'staging', 'demo'
+                  :pass_through
+                when 'development'
+                  :exceptions
+                when 'test'
+                  :collect
+                else
+                  :pass_through
+              end
+            else
+              :pass_through
+            end
+          end
+
+          Struct.new(:mode).new(default_mode)
+        end
+      end
+
+    end
+  end
+end

data/lib/tphases/initialization.rb

@@ -0,0 +1,26 @@
+module TPhases
+  module Initialization
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # initiates TPhases.  Any overrides to config mode need to be made prior to running this.
+      def initiate!
+        case config.mode
+          when :pass_through
+            require 'tphases/modes/pass_through_mode'
+            include TPhases::Modes::PassThroughMode
+          when :exceptions
+            require 'tphases/modes/exceptions_mode'
+            include TPhases::Modes::ExceptionsMode
+          when :collect
+            require 'tphases/modes/collect_mode'
+            include TPhases::Modes::CollectMode
+          else
+            raise "TPhases mode must be one of :pass_through, :exceptions, or :collect, but instead is #{config.mode}"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/tphases/modes/collect_mode.rb

@@ -0,0 +1,60 @@
+require 'tphases/transactional_violation'
+require 'tphases/modes/helpers/transactional_violations_helper'
+
+# the default 'test' mode, Collect Mode collects incidents of
+# immediately inside of a TPhase block if a transactional violation occurs
+module TPhases
+  module Modes
+    module CollectMode
+      extend ActiveSupport::Concern
+      include Helpers::TransactionalViolationsHelper
+
+      included do
+        add_rspec_after! if defined?(RSpec)
+        @violations = []
+      end
+
+
+      module ClassMethods
+        attr_accessor :violations
+
+        private
+        def write_violation_action(sql, call_stack)
+          violations << { :type => :write, :call_stack => call_stack, :sql => sql }
+        end
+
+        def read_violation_action(sql, call_stack)
+          violations << { :type => :read, :call_stack => call_stack, :sql => sql }
+        end
+
+        def no_transactions_violation_action(sql, call_stack)
+          violations << { :type => :no_transactions, :call_stack => call_stack, :sql => sql }
+        end
+
+        # 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
+                end
+              ensure
+                # reset violations list:
+                TPhases.violations = []
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/tphases/modes/exceptions_mode.rb

@@ -0,0 +1,30 @@
+require 'tphases/transactional_violation'
+require 'tphases/modes/helpers/transactional_violations_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
+module TPhases
+  module Modes
+    module ExceptionsMode
+      extend ActiveSupport::Concern
+      include Helpers::TransactionalViolationsHelper
+
+      module ClassMethods
+        private
+
+        def write_violation_action(sql, caller)
+          raise TransactionalViolation.new "#{sql} ran inside of a 'write_phase' block."
+        end
+
+        def read_violation_action(sql, caller)
+          raise TransactionalViolation.new "#{sql} ran inside of a 'read_phase' block."
+        end
+
+        def no_transactions_violation_action(sql, caller)
+          raise TransactionalViolation.new "#{sql} ran inside of a 'no_transactions_phase' block."
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+require 'active_support/notifications'
+require 'active_support/version'
+
+module TPhases
+  module Modes
+    module Helpers
+
+      # this helper is included by the CollectMode and the ExceptionsMode modules.
+      # methods expected to be implemented by those modes are #write_violation_action, #read_violation_action, and
+      # #no_transactions_violation_action
+      module TransactionalViolationsHelper
+        extend ActiveSupport::Concern
+
+        included do
+          define_phase_methods!
+        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!
+                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
+
+            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
+          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
+          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
+          end
+
+          def no_transactions_phase_subscription_callback
+            Proc.new do |name, date, date2, sha, args|
+              no_transactions_violation_action(args[:sql], caller)
+            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
+
+      end
+    end
+  end
+end

data/lib/tphases/modes/pass_through_mode.rb

@@ -0,0 +1,22 @@
+# the default 'production' mode, PassThrough mode does nothing but called the yielded block
+module TPhases
+  module Modes
+    module PassThroughMode
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def read_phase
+          yield
+        end
+
+        def write_phase
+          yield
+        end
+
+        def no_transactions_phase
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/tphases/transactional_violation.rb

@@ -0,0 +1,3 @@
+class TransactionalViolation < StandardError
+
+end

data/lib/tphases/version.rb

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

data/lib/tphases.rb

@@ -0,0 +1,9 @@
+require 'active_support/concern'
+require "tphases/version"
+require "tphases/config"
+require "tphases/initialization"
+
+module TPhases
+  include TPhases::Config
+  include TPhases::Initialization
+end

data/spec/fixtures/database.yml

@@ -0,0 +1,4 @@
+adapter: sqlite3
+database: spec/fixtures/database.sqlite3
+pool: 5
+timeout: 5000

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'active_record'
+require 'tphases/modes/collect_mode'
+
+describe TPhases::Modes::CollectMode do
+  subject { Module.new { include TPhases::Modes::CollectMode } }
+
+  include_context "setup mode specs"
+
+  describe '.no_transactions_phase' do
+    it "should add to the violations list for all violations" do
+      expect {
+        subject.no_transactions_phase do
+          ActiveRecord::Base.connection.select_all(read_sql)
+        end
+      }.to change { subject.send(:violations).size }.from(0).to(1)
+    end
+
+    it "should add multiple violations if there are multiple" do
+      expect {
+        subject.no_transactions_phase do
+          ActiveRecord::Base.connection.select_all(read_sql)
+          ActiveRecord::Base.connection.select_all(write_sql)
+        end
+      }.to change { subject.send(:violations).size }.from(0).to(2)
+    end
+  end
+
+  describe '.read_phase' do
+    it "should not add a violation for read transactions" do
+      expect {
+        subject.read_phase do
+          ActiveRecord::Base.connection.select_all(read_sql)
+        end
+      }.to_not change { subject.send(:violations).size }
+    end
+    it "should add a violation for write transactions" do
+      expect {
+        subject.read_phase do
+          ActiveRecord::Base.connection.select_all(write_sql)
+        end
+      }.to change { subject.send(:violations).size }.from(0).to(1)
+
+    end
+  end
+
+  describe '.write_phase' do
+    it "should not add a violation for write transactions" do
+      expect {
+        subject.write_phase do
+          ActiveRecord::Base.connection.select_all(write_sql)
+        end
+      }.to_not change { subject.send(:violations).size }
+    end
+    it "should add a violation for read transactions" do
+      expect {
+        subject.write_phase do
+          ActiveRecord::Base.connection.select_all(read_sql)
+        end
+      }.to change { subject.send(:violations).size }.from(0).to(1)
+
+    end
+  end
+
+end

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'active_record'
+require 'tphases/modes/exceptions_mode'
+
+describe TPhases::Modes::ExceptionsMode do
+  subject { Module.new { include TPhases::Modes::ExceptionsMode } }
+
+  include_context "setup mode specs"
+
+  describe '.no_transactions_phase' do
+    it "should throw an exception disallow read and write transactions from running in this phase" do
+      expect {
+        subject.no_transactions_phase do
+          ActiveRecord::Base.connection.select_all(read_sql)
+        end
+      }.to raise_error(ActiveRecord::StatementInvalid, "TransactionalViolation: #{read_sql} ran inside of a 'no_transactions_phase' block.: #{read_sql}")
+
+      expect {
+        subject.no_transactions_phase do
+          ActiveRecord::Base.connection.select_all(write_sql)
+        end
+      }.to raise_error(ActiveRecord::StatementInvalid, "TransactionalViolation: #{write_sql} ran inside of a 'no_transactions_phase' block.: #{write_sql}")
+    end
+  end
+
+  describe '.read_phase' do
+    it "should allow read transactions" do
+      expect {
+        subject.read_phase do
+          ActiveRecord::Base.connection.select_all(read_sql)
+        end
+      }.to_not raise_error
+    end
+    it "should disallow write transactions" do
+      expect {
+        subject.read_phase do
+          ActiveRecord::Base.connection.select_all(write_sql)
+        end
+      }.to raise_error(ActiveRecord::StatementInvalid, "TransactionalViolation: #{write_sql} ran inside of a 'read_phase' block.: #{write_sql}")
+
+    end
+  end
+
+  describe '.write_phase' do
+    it "should allow write transactions" do
+      expect {
+        subject.write_phase do
+          ActiveRecord::Base.connection.select_all(write_sql)
+        end
+      }.to_not raise_error
+    end
+    it "should disallow read transactions" do
+      expect {
+        subject.write_phase do
+          ActiveRecord::Base.connection.select_all(read_sql)
+        end
+      }.to raise_error(ActiveRecord::StatementInvalid, "TransactionalViolation: #{read_sql} ran inside of a 'write_phase' block.: #{read_sql}")
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+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 } }
+
+    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) }
+      end
+    end
+
+    describe " #write_transactional_violation?" 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 }
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'active_record'
+require 'tphases/modes/pass_through_mode'
+
+describe TPhases::Modes::PassThroughMode do
+  subject { Module.new { include TPhases::Modes::PassThroughMode } }
+
+  include_context "setup mode specs"
+
+  describe '.no_transactions_phase, .read_phase, .write_phase' do
+    it "should allow anything" do
+      subject.no_transactions_phase do
+        ActiveRecord::Base.connection.select_all(read_sql)
+        ActiveRecord::Base.connection.select_all(write_sql)
+      end
+
+      subject.write_phase do
+        ActiveRecord::Base.connection.select_all(read_sql)
+        ActiveRecord::Base.connection.select_all(write_sql)
+      end
+
+      subject.read_phase do
+        ActiveRecord::Base.connection.select_all(read_sql)
+        ActiveRecord::Base.connection.select_all(write_sql)
+      end
+
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+LIB_ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+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'
+end
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+require File.join(File.expand_path('../../', __FILE__), 'lib', 'tphases')

data/spec/support/setup_modes_specs_context.rb

@@ -0,0 +1,12 @@
+shared_context "setup mode specs" do
+
+  before do
+    dbconfig             = YAML::load(File.open(LIB_ROOT + '/spec/fixtures/database.yml'))
+    dbconfig['database'] = LIB_ROOT + '/' + dbconfig['database']
+    ActiveRecord::Base.establish_connection(dbconfig)
+  end
+
+  let(:read_sql) { 'select * from posts' }
+  let(:write_sql) { "insert into posts values ('foobaz')" }
+
+end

data/test_script.rb

@@ -0,0 +1,5 @@
+require 'pry'
+require 'active_record'
+dbconfig = YAML::load(File.open('spec/fixtures/database.yml'))
+ActiveRecord::Base.establish_connection(dbconfig)
+puts ActiveRecord::Base.connection.select_all('select * from posts')

data/tphases.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tphases/version'
+
+Gem::Specification.new do |gem|
+  gem.name    = "tphases"
+  gem.version = Tphases::VERSION
+  gem.authors = ["Charles Finkel"]
+  gem.email   = ["charles.finkel@gmail.com"]
+
+  description     = %q{TPhases (Transactional Phases) is a support framework that helps you build your Rails request life cycles into read-only and write-only phases.}
+  gem.description = description
+  gem.summary     = description
+  gem.homepage    = "https://github.com/charleseff/tphases"
+
+  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 'activesupport'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'debugger'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'activerecord'
+  gem.add_development_dependency 'pry'
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: tphases
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Charles Finkel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: debugger
+  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: sqlite3
+  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: activerecord
+  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: pry
+  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: TPhases (Transactional Phases) is a support framework that helps you
+  build your Rails request life cycles into read-only and write-only phases.
+email:
+- charles.finkel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tphases.rb
+- lib/tphases/config.rb
+- lib/tphases/initialization.rb
+- lib/tphases/modes/collect_mode.rb
+- lib/tphases/modes/exceptions_mode.rb
+- lib/tphases/modes/helpers/transactional_violations_helper.rb
+- lib/tphases/modes/pass_through_mode.rb
+- lib/tphases/transactional_violation.rb
+- lib/tphases/version.rb
+- spec/fixtures/database.sqlite3
+- spec/fixtures/database.yml
+- spec/lib/tphases/modes/collect_mode_spec.rb
+- spec/lib/tphases/modes/exceptions_mode_spec.rb
+- spec/lib/tphases/modes/helpers/transactional_violations_helper_spec.rb
+- spec/lib/tphases/modes/pass_through_mode_spec.rb
+- spec/spec_helper.rb
+- spec/support/setup_modes_specs_context.rb
+- test_script.rb
+- tphases.gemspec
+homepage: https://github.com/charleseff/tphases
+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: TPhases (Transactional Phases) is a support framework that helps you build
+  your Rails request life cycles into read-only and write-only phases.
+test_files:
+- spec/fixtures/database.sqlite3
+- spec/fixtures/database.yml
+- spec/lib/tphases/modes/collect_mode_spec.rb
+- spec/lib/tphases/modes/exceptions_mode_spec.rb
+- spec/lib/tphases/modes/helpers/transactional_violations_helper_spec.rb
+- spec/lib/tphases/modes/pass_through_mode_spec.rb
+- spec/spec_helper.rb
+- spec/support/setup_modes_specs_context.rb