suture 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8719743f9e00506715c4d1ce0246d845499618c2
-  data.tar.gz: 95298c758bedaf269b91f309658829cb44895f2c
+  metadata.gz: b9c19b3ad957fa4dee235e314fcacde3aeac88c3
+  data.tar.gz: de6d831eaaecf0ff8b7edde1397b7c1304a486c2
 SHA512:
-  metadata.gz: 4854f0c0472d24c6e49d6be7131e66423d638538505ff2883dd797d6554f6e2a4b8a1fd9ed1ec4707fe90f8b3a13b51053e988e4d12efe824b2a82d3fcf7988f
-  data.tar.gz: e4b83c187c95e674576f9bc230b7c18e89289917abd82536f2cf07b37ea0839cecfa2c6ad550ea22beeb28ce53ee0c03db2c556c2e3d36341642022169cf6513
+  metadata.gz: e35674ad68833373e8d926437c0c272f7f9b216c821b150aec70fc74250e29a188f698d277bdca8dcf48f67baa534bbdcd355652ff56b9d5f991c38802955608
+  data.tar.gz: 4fa715fc19bbb2911c3e028ab360cf557b49b87d564764c4cb4d64109362d5bc00683c294a9d3e6d2ecfc72de6ebbf879540363898e0e60ee41f52f063b90efe

data/.gitignore

@@ -9,3 +9,4 @@
 /tmp/
 /db/
 /log/
+/ignore/

data/README.md

@@ -128,6 +128,7 @@ We could write a test like this:
 ``` ruby
 class MyWorkerCharacterizationTest < Minitest::Test
   def setup
+    super
     # Load the test data needed to resemble the environment when recording
   end
 
@@ -192,6 +193,7 @@ interactions:
 ``` ruby
 class MyWorkerCharacterizationTest < Minitest::Test
   def setup
+    super
     # Load the test data needed to resemble the environment when recording
   end
 
@@ -270,7 +272,7 @@ arguments and broader state.
 Suture gives users a way to experiment with risky refactors by deploying them to
 a staging environment and running both the original and new code paths
 side-by-side, raising an error in the event they don't return the same value.
-This is governed by the `:run_both` to `true`:
+This is governed by the `:call_both` to `true`:
 
 ``` ruby
 class MyWorker
@@ -279,7 +281,7 @@ class MyWorker
       old: LegacyWorker.new,
       new: NewWorker.new,
       args: [id],
-      run_both: true
+      call_both: true
     }))
   end
 end
@@ -344,7 +346,7 @@ end
 ### Retrying failures
 
 Since the legacy code path hasn't been deleted yet, there's no reason to leave
-users hanging if the new code path explodes. By setting the `:fallback_to_old`
+users hanging if the new code path explodes. By setting the `:call_old_on_error`
 entry to `true`, Suture will rescue any errors raised from the new code path and
 attempt to invoke the legacy code path instead.
 
@@ -355,7 +357,7 @@ class MyWorker
       old: LegacyWorker.new,
       new: NewWorker.new,
       args: [id],
-      fallback_to_old: true
+      call_old_on_error: true
     }))
   end
 end
@@ -476,5 +478,5 @@ seeing false negatives:
   * If a recording was made in error, you can always delete it, either by
     dropping Suture's database (which is, by default, stored in
     `db/suture.sqlite3`) or by observing the ID of the recording from an error
-    message and invoking `Suture.delete(42)`
+    message and invoking `Suture.delete!(42)`
 

data/Rakefile

@@ -26,15 +26,17 @@ Rake::TestTask.new(:everything) do |t|
   ]
 end
 
-require 'github_changelog_generator/task'
-GitHubChangelogGenerator::RakeTask.new :changelog
-task :changelog_commit do
-  require "suture"
-  cmd = "git commit -m \"Changelog for #{Suture::VERSION}\" -- CHANGELOG.md"
-  puts "-------> #{cmd}"
-  system cmd
+if Gem.ruby_version >= Gem::Version.new("2.2.2")
+  require 'github_changelog_generator/task'
+  GitHubChangelogGenerator::RakeTask.new :changelog
+  task :changelog_commit do
+    require "suture"
+    cmd = "git commit -m \"Changelog for #{Suture::VERSION}\" -- CHANGELOG.md"
+    puts "-------> #{cmd}"
+    system cmd
+  end
+  Rake::Task["release:source_control_push"].enhance([:changelog, :changelog_commit])
 end
 
-Rake::Task["release:source_control_push"].enhance([:changelog, :changelog_commit])
 
 task :default => :everything

data/lib/suture/adapter/dictaphone.rb

@@ -40,7 +40,7 @@ module Suture::Adapter
       rows.map { |row| row_to_observation(row) }
     end
 
-    def delete(id)
+    def delete!(id)
       log_info("deleting call with ID: #{id}")
       Suture::Wrap::Sqlite.delete(@db, :observations, "where id = ?", [id])
     end

data/lib/suture/config.rb

@@ -0,0 +1,21 @@
+require "suture/comparator"
+
+module Suture
+  DEFAULT_OPTIONS = {
+    :database_path => "db/suture.sqlite3",
+    :comparator => Comparator.new,
+    :log_level => "INFO",
+    :log_file => nil,
+    :log_stdout => true,
+    :raise_on_result_mismatch => true
+  }
+
+  def self.config(config = {})
+    @config ||= DEFAULT_OPTIONS.dup
+    @config.merge!(config)
+  end
+
+  def self.config_reset!
+    @config = DEFAULT_OPTIONS.dup
+  end
+end

data/lib/suture/{builds_plan.rb → create/builds_plan.rb}

@@ -3,7 +3,9 @@ require "suture/util/env"
 
 module Suture
   class BuildsPlan
-    UN_ENV_IABLE_OPTIONS = [:name, :old, :new, :args, :comparator]
+    UN_ENV_IABLE_OPTIONS = [:name, :old, :new, :args, :comparator, :after_new,
+                            :after_old, :on_new_error, :on_old_error,
+                            :expected_error_types]
 
     def build(name, options = {})
       Value::Plan.new(

data/lib/suture/{chooses_surgeon.rb → create/chooses_surgeon.rb}

@@ -1,5 +1,7 @@
 require "suture/adapter/log"
 require "suture/surgeon/observer"
+require "suture/surgeon/auditor"
+require "suture/surgeon/remediator"
 require "suture/surgeon/no_op"
 
 module Suture
@@ -7,6 +9,7 @@ module Suture
     include Suture::Adapter::Log
 
     def choose(plan)
+      return Surgeon::NoOp.new if plan.disable
       if plan.record_calls
         if plan.new
           log_warn <<-MSG.gsub(/^ {12}/,'')
@@ -16,6 +19,10 @@ module Suture
           MSG
         end
         Surgeon::Observer.new
+      elsif plan.call_both
+        Surgeon::Auditor.new
+      elsif plan.call_old_on_error
+        Surgeon::Remediator.new
       else
         Surgeon::NoOp.new
       end

data/lib/suture/create/validates_plan.rb

@@ -0,0 +1,90 @@
+require "suture/error/invalid_plan"
+
+module Suture
+  class ValidatesPlan
+    REQUIREMENTS = {
+      :name => "in order to identify recorded calls",
+      :old => "in order to call the legacy code path (must respond to `:call`)",
+      :args => "in order to differentiate recorded calls (if the code you're changing doesn't take arguments, you can set :args to `[]` but should probably consider creating a seam inside of it which can--consult the README for more advice)"
+    }
+
+    VALIDATIONS = {
+      :name => {
+        :test => lambda { |name| name.to_s.size < 256 },
+        :message => "must be less than 256 characters"
+      },
+      :old => CALLABLE_VALIDATION = ({
+        :test => lambda { |old| old.respond_to?(:call) },
+        :message => "must respond to `call` (e.g. `dog.method(:bark)` or `->(*args){ dog.bark(*args) }`)"
+      }),
+      :new => CALLABLE_VALIDATION,
+      :comparator => CALLABLE_VALIDATION.merge(
+        :message => "must respond to `call` (e.g. `MyComparator.new` or `->(recorded, actual) { recorded == actual }`)"
+      )
+    }
+
+    CONFLICTS = [
+      lambda { |plan|
+        if plan.record_calls && !plan.database_path
+          ":record_calls is enabled, but :database_path is nil, so Suture doesn't know where to record calls to the seam."
+        end
+      },
+      lambda { |plan|
+        if plan.record_calls && plan.call_both
+          ":record_calls & :call_both are both enabled and conflict with one another. :record_calls will only invoke the old code path (intended for characterization of the old code path and initial development of the new code path), whereas :call_both will invoke the new path and the old to compare their results after development of the new code path is initially complete (typically in a pre-production environment to validate the behavior of the new code path is consistent with the old). If you're still actively developing the new code path and need more recordings to feed Suture.verify, disable :call_both; otherwise, it's likely time to turn off :record_calls on this seam."
+        end
+      },
+      lambda { |plan|
+        if plan.record_calls && plan.call_old_on_error
+          ":record_calls & :call_old_on_error are both enabled and conflict with one another. :record_calls will only invoke the old code path (intended for characterization of the old code path and initial development of the new code path), whereas :call_old_on_error will call the new code path unless an error is raised, in which case it will fall back on the old code path."
+        end
+      },
+      lambda { |plan|
+        if plan.call_both && plan.call_old_on_error
+          ":call_both & :call_old_on_error are both enabled and conflict with one another. :call_both is designed for pre-production environments and will call both the old and new code paths to compare their results, whereas :call_old_on_error is designed for production environments where it is safe to call the old code path in the event that the new code path fails unexpectedly"
+        end
+      },
+      lambda { |plan|
+        if plan.call_both && !plan.new.respond_to?(:call)
+          ":call_both is set but :new is either not set or is not callable. In order to call both code paths, both :old and :new must be set and callable."
+        end
+      },
+      lambda { |plan|
+        if plan.call_old_on_error && !plan.new.respond_to?(:call)
+          ":call_old_on_error is set but :new is either not set or is not callable. This mode is designed for after the :new code path has been developed and run in production-like environments, where :old is only kept around as a fallback to retry in the event that :new raises an unexpected error. Either specify a :new code path or disable :call_old_on_error."
+        end
+      }
+    ]
+
+    def validate(plan)
+      if (missing = missing_attrs(plan)).any?
+        raise Error::InvalidPlan.missing_requirements(missing)
+      elsif (invalids = invalid_attrs(plan)).any?
+        raise Error::InvalidPlan.invalid_options(invalids)
+      elsif (conflicts = conflicting_attrs(plan)).any?
+        raise Error::InvalidPlan.conflicting_options(conflicts)
+      else
+        plan
+      end
+    end
+
+    def missing_attrs(plan)
+      REQUIREMENTS.select { |(name, _)|
+        !plan.send(name)
+      }
+    end
+
+    def invalid_attrs(plan)
+      VALIDATIONS.select { |name, rule|
+        next unless attr = plan.send(name)
+        !rule[:test].call(attr)
+      }
+    end
+
+    def conflicting_attrs(plan)
+      CONFLICTS.map { |rule|
+        rule.call(plan)
+      }.compact
+    end
+  end
+end

data/lib/suture/create.rb

@@ -0,0 +1,12 @@
+require "suture/create/builds_plan"
+require "suture/create/validates_plan"
+require "suture/create/chooses_surgeon"
+require "suture/create/performs_surgery"
+
+module Suture
+  def self.create(name, options)
+    plan = ValidatesPlan.new.validate(BuildsPlan.new.build(name, options))
+    surgeon = ChoosesSurgeon.new.choose(plan)
+    PerformsSurgery.new.perform(plan, surgeon)
+  end
+end

data/lib/suture/delete.rb

@@ -0,0 +1,9 @@
+require "suture/create/builds_plan"
+require "suture/adapter/dictaphone"
+
+module Suture
+  def self.delete!(id, options = {})
+    plan = BuildsPlan.new.build(:name_not_used_here, options)
+    Adapter::Dictaphone.new(plan).delete!(id)
+  end
+end

data/lib/suture/error/invalid_plan.rb

@@ -0,0 +1,41 @@
+module Suture::Error
+  class InvalidPlan < StandardError
+    HEADER = "Suture was unable to create your seam, because options passed to `Suture.create` were invalid."
+
+    def self.missing_requirements(requirements)
+      new <<-MSG.gsub(/^ {8}/,'')
+        #{HEADER}
+
+        The following options are required:
+
+          #{requirements.map {|(name,explanation)|
+              "* #{name.inspect} - #{explanation}"
+            }.join("\n  ")}
+      MSG
+    end
+
+    def self.invalid_options(invalids)
+      new <<-MSG.gsub(/^ {8}/,'')
+        #{HEADER}
+
+        The following options were invalid:
+
+          #{invalids.map {|(name,rule)|
+              "* #{name.inspect} - #{rule[:message]}"
+            }.join("\n  ")}
+      MSG
+    end
+
+    def self.conflicting_options(conflicts)
+      new <<-MSG.gsub(/^ {8}/,'')
+        #{HEADER}
+
+        Suture isn't sure how to best handle the combination of options passed:
+
+          #{conflicts.map {|message|
+              "* #{message}"
+            }.join("\n  ")}
+      MSG
+    end
+  end
+end

data/lib/suture/error/observation_conflict.rb

@@ -19,7 +19,6 @@ module Suture::Error
         Previously-observed return value: ```
           #{@old_result.inspect}
         ```
-
         Newly-observed return value: ```
           #{@new_result.inspect}
         ```
@@ -49,7 +48,7 @@ module Suture::Error
            recorded result is in error, you can delete it from Suture's database
            with:
 
-             Suture.delete(#{@old_id})
+             Suture.delete!(#{@old_id})
       MSG
     end
   end

data/lib/suture/error/result_mismatch.rb

@@ -0,0 +1,58 @@
+module Suture::Error
+  class ResultMismatch < StandardError
+    def initialize(plan, new_result, old_result)
+      @plan = plan
+      @new_result = new_result
+      @old_result = old_result
+    end
+
+    def message
+      expected_message = <<-MSG.gsub(/^ {8}/,'')
+        The results from the old & new code paths did not match for the seam
+        #{@plan.name.inspect} and Suture is raising this error because the `:call_both`
+        option is enabled, because both code paths are expected to return the
+        same result.
+
+        Arguments: ```
+          #{@plan.args.inspect}
+        ```
+        The new code path returned: ```
+          #{@new_result.inspect}
+        ```
+        The old code path returned: ```
+          #{@old_result.inspect}
+        ```
+
+        Here's what we recommend you do next:
+
+        1. Verify that this mismatch does not represent a missed requirement in
+           the new code path. If it does, implement it!
+
+        2. If either (or both) code path has a side effect that impacts the
+           return value of the other, consider passing an `:after_old` and/or
+           `:after_new` hook to clean up your application's state well enough to
+           run both paths one-after-the-other safely.
+
+        3. If the two return values above are sufficiently similar for the
+           purpose of your application, consider writing your own custom
+           comparator that relaxes the comparison (e.g. only checks equivalence
+           of the attributes that matter). See the README for more info on custom
+           comparators.
+
+        4. If the new code path is working as desired (i.e. the old code path had
+           a bug for this argument and you don't want to reimplement it just to
+           make them perfectly in sync with one another), consider writing a
+           one-off comparator for this seam that will ignore the affected range
+           of arguments. See the README for more info on custom comparators.
+
+        By default, Suture's :call_both mode will log a warning and raise an
+        error when the results of each code path don't match. It is intended for
+        use in any pre-production environment to "try out" the new code path
+        before pushing it to production. If, for whatever reason, this error is
+        too disruptive and logging is sufficient for monitoring results, you may
+        disable this error by setting `:raise_on_result_mismatch` to false.
+      MSG
+
+    end
+  end
+end

data/lib/suture/error/verification_failed.rb

@@ -105,7 +105,7 @@ module Suture::Error
 
            Ideas to fix this:
              * Focus on this test by setting ENV var `SUTURE_VERIFY_ONLY=#{expected.id}`
-             * Is the recording wrong? Delete it! `Suture.delete(#{expected.id})`
+             * Is the recording wrong? Delete it! `Suture.delete!(#{expected.id})`
       MSG
     end
 

data/lib/suture/reset.rb

@@ -0,0 +1,9 @@
+require "suture/adapter/log"
+
+module Suture
+  def self.reset!
+    Suture.config_reset!
+    Adapter::Log.reset!
+  end
+end
+

data/lib/suture/surgeon/auditor.rb

@@ -0,0 +1,29 @@
+require "suture/error/result_mismatch"
+require "suture/util/scalpel"
+
+module Suture::Surgeon
+  class Auditor
+    include Suture::Adapter::Log
+
+    def operate(plan)
+      scalpel = Suture::Util::Scalpel.new
+      new_result = scalpel.cut(plan, :new)
+      old_result = scalpel.cut(plan, :old)
+      if !plan.comparator.call(old_result, new_result)
+        log_warn <<-MSG.gsub(/^ {10}/,'')
+          Seam #{plan.name.inspect} is set to :call_both the :new and :old code
+          paths, but they did not match. The new result was: ```
+            #{new_result.inspect}
+          ```
+          The old result was: ```
+            #{old_result.inspect}
+          ```
+        MSG
+        if plan.raise_on_result_mismatch
+          raise Suture::Error::ResultMismatch.new(plan, new_result, old_result)
+        end
+      end
+      new_result
+    end
+  end
+end

data/lib/suture/surgeon/no_op.rb

@@ -1,8 +1,10 @@
+require "suture/util/scalpel"
+
 module Suture::Surgeon
   class NoOp
     def operate(plan)
       return unless plan.old
-      plan.old.call(*plan.args)
+      Suture::Util::Scalpel.new.cut(plan, :old)
     end
   end
 end

data/lib/suture/surgeon/observer.rb

@@ -1,23 +1,14 @@
+require "suture/util/scalpel"
 require "suture/adapter/dictaphone"
 
 module Suture::Surgeon
   class Observer
     def operate(plan)
       dictaphone = Suture::Adapter::Dictaphone.new(plan)
-      invoke(plan).tap do |result|
+      Suture::Util::Scalpel.new.cut(plan, :old).tap do |result|
         dictaphone.record(result)
       end
     end
-
-    private
-
-    def invoke(plan)
-      if plan.args
-        plan.old.call(*plan.args)
-      else
-        plan.old.call
-      end
-    end
   end
 end
 

data/lib/suture/surgeon/remediator.rb

@@ -0,0 +1,21 @@
+require "suture/util/scalpel"
+
+module Suture::Surgeon
+  class Remediator
+    def initialize
+      @scalpel = Suture::Util::Scalpel.new
+    end
+
+    def operate(plan)
+      begin
+        @scalpel.cut(plan ,:new)
+      rescue StandardError => actual_error
+        if plan.expected_error_types.any? { |e| actual_error.is_a?(e) }
+          raise actual_error
+        else
+          @scalpel.cut(plan, :old)
+        end
+      end
+    end
+  end
+end

data/lib/suture/util/scalpel.rb

@@ -0,0 +1,41 @@
+module Suture::Util
+  class Scalpel
+    def cut(plan, location, args_override = nil)
+      args = args(plan, args_override)
+      begin
+        plan.send(location).call(*args).tap do |result|
+          call_after_hook(plan, location, args, result)
+        end
+      rescue StandardError => error
+        call_error_hook(plan, location, args, error)
+        raise error
+      end
+    end
+
+    private
+
+    def call_after_hook(plan, location, args, result)
+      return unless after_hook = try(plan, "after_#{location}")
+      after_hook.call(plan.name, args, result)
+    end
+
+    def call_error_hook(plan, location, args, error)
+      return if plan.expected_error_types.any? {|e| error.kind_of?(e) }
+      return unless error_hook = try(plan, "on_#{location}_error")
+      error_hook.call(plan.name, args, error)
+    end
+
+    def args(plan, args_override)
+      return args_override if args_override
+      if plan.respond_to?(:args)
+        plan.args
+      end
+    end
+
+    def try(plan, method)
+      return unless plan.respond_to?(method)
+      plan.send(method)
+    end
+
+  end
+end

data/lib/suture/value/plan.rb

@@ -1,14 +1,27 @@
 module Suture::Value
   class Plan
-    attr_reader :name, :old, :new, :args, :record_calls, :comparator, :database_path
+    attr_reader :name, :old, :new, :args, :after_new, :after_old, :on_new_error,
+                :on_old_error, :database_path, :record_calls, :comparator,
+                :call_both, :raise_on_result_mismatch, :call_old_on_error,
+                :expected_error_types, :disable
+
     def initialize(attrs = {})
       @name = attrs[:name]
       @old = attrs[:old]
       @new = attrs[:new]
       @args = attrs[:args]
+      @after_new = attrs[:after_new]
+      @after_old = attrs[:after_old]
+      @on_new_error = attrs[:on_new_error]
+      @on_old_error = attrs[:on_old_error]
+      @database_path = attrs[:database_path]
       @record_calls = !!attrs[:record_calls]
       @comparator = attrs[:comparator]
-      @database_path = attrs[:database_path]
+      @call_both = !!attrs[:call_both]
+      @raise_on_result_mismatch = !!attrs[:raise_on_result_mismatch]
+      @call_old_on_error = !!attrs[:call_old_on_error]
+      @expected_error_types = attrs[:expected_error_types] || []
+      @disable = !!attrs[:disable]
     end
   end
 end

data/lib/suture/value/test_plan.rb

@@ -2,11 +2,17 @@ module Suture::Value
   class TestPlan
     attr_accessor :name, :subject,
                   :verify_only, :fail_fast, :call_limit, :time_limit,
-                  :error_message_limit, :random_seed,
-                  :comparator, :database_path
+                  :error_message_limit, :random_seed, :comparator,
+                  :database_path, :after_subject, :on_subject_error,
+                  :expected_error_types
+
     def initialize(attrs = {})
-      assign_simple_ivars!(attrs, :name, :subject, :fail_fast, :comparator, :database_path)
-      assign_integral_ivars(attrs, :verify_only, :call_limit, :time_limit, :error_message_limit)
+      assign_simple_ivars!(attrs, :name, :subject, :fail_fast, :comparator,
+                                  :database_path, :after_subject,
+                                  :on_subject_error)
+      assign_integral_ivars!(attrs, :verify_only, :call_limit, :time_limit,
+                                   :error_message_limit)
+      @expected_error_types = attrs[:expected_error_types] || []
       @random_seed = determine_random_seed(attrs)
     end
 
@@ -18,12 +24,15 @@ module Suture::Value
       end
     end
 
-    def assign_integral_ivars(attrs, *names)
-      assign_simple_ivars!(
-        Hash[attrs.select {|(k,_)| names.include?(k) }.
-                   map { |(k,v)| [k, v.nil? ? nil : v.to_i]}],
-        *names
-      )
+    def assign_integral_ivars!(attrs, *names)
+      assign_simple_ivars!(massage_values(attrs, names) {|v| v.to_i }, *names)
+    end
+
+    def massage_values(attrs, names, &blk)
+      Hash[
+        attrs.select {|(k,_)| names.include?(k) }.
+              map { |(k,v)| [k, v.nil? ? nil : blk.call(v) ]}
+      ]
     end
 
     def determine_random_seed(attrs)

data/lib/suture/{prescribes_test_plan.rb → verify/prescribes_test_plan.rb}

@@ -3,14 +3,11 @@ require "suture/util/env"
 
 module Suture
   class PrescribesTestPlan
-    UN_ENV_IABLE_OPTIONS = [:name, :subject, :comparator]
-    DEFAULT_TEST_OPTIONS = {
-      :fail_fast => false
-    }
+    UN_ENV_IABLE_OPTIONS = [:name, :subject, :comparator, :after_subject,
+                            :on_subject_error, :expected_error_types]
 
     def prescribe(name, options = {})
-      Value::TestPlan.new(DEFAULT_TEST_OPTIONS.
-                          merge(Suture.config).
+      Value::TestPlan.new(Suture.config.
                           merge(options).
                           merge(:name => name).
                           merge(Suture::Util::Env.to_map(UN_ENV_IABLE_OPTIONS)))

data/lib/suture/{tests_patient.rb → verify/tests_patient.rb}

@@ -1,11 +1,16 @@
 require "suture/adapter/dictaphone"
 require "suture/value/test_results"
-require "suture/util/timer"
+require "suture/util/scalpel"
 require "suture/util/shuffle"
+require "suture/util/timer"
 require "backports/1.9.2/random"
 
 module Suture
   class TestsPatient
+    def initialize
+      @scalpel = Suture::Util::Scalpel.new
+    end
+
     def test(test_plan)
       experienced_failure_in_life = false
       timer = Suture::Util::Timer.new(test_plan.time_limit) unless test_plan.time_limit.nil?
@@ -45,11 +50,7 @@ module Suture
     def invoke(test_plan, observation)
       {}.tap do |result|
         begin
-          result[:new_result] = if observation.args
-                                  test_plan.subject.call(*observation.args)
-                                else
-                                  test_plan.subject.call
-                                end
+          result[:new_result] = @scalpel.cut(test_plan, :subject, observation.args)
           result[:passed] = test_plan.comparator.call(observation.result, result[:new_result])
         rescue StandardError => e
           result[:passed] = false

data/lib/suture/verify.rb

@@ -0,0 +1,14 @@
+require "suture/verify/prescribes_test_plan"
+require "suture/verify/tests_patient"
+require "suture/verify/interprets_results"
+
+module Suture
+  def self.verify(name, options)
+    test_plan = Suture::PrescribesTestPlan.new.prescribe(name, options)
+    test_results = Suture::TestsPatient.new.test(test_plan)
+    if test_results.failed?
+      Suture::InterpretsResults.new.interpret(test_plan, test_results)
+    end
+  end
+end
+

data/lib/suture/version.rb

@@ -1,3 +1,3 @@
 module Suture
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

data/lib/suture/wrap/logger.rb

@@ -30,11 +30,11 @@ module Suture::Wrap
     end
 
     class NullLogger
-      def formatter=; end
-      def level=; end
-      def debug; end
-      def info; end
-      def warn; end
+      def formatter=(*args); end
+      def level=(*args); end
+      def debug(*args); end
+      def info(*args); end
+      def warn(*args); end
     end
   end
 end

data/lib/suture.rb

@@ -1,51 +1,8 @@
 require "suture/version"
 
-require "suture/builds_plan"
-require "suture/chooses_surgeon"
-require "suture/performs_surgery"
+require "suture/create"
+require "suture/verify"
+require "suture/delete"
+require "suture/config"
+require "suture/reset"
 
-require "suture/prescribes_test_plan"
-require "suture/tests_patient"
-require "suture/interprets_results"
-
-require "suture/adapter/log"
-require "suture/comparator"
-
-module Suture
-  DEFAULT_OPTIONS = {
-    :database_path => "db/suture.sqlite3",
-    :comparator => Comparator.new,
-    :log_level => "INFO",
-    :log_file => nil,
-    :log_stdout => true
-  }
-
-  def self.create(name, options)
-    plan = BuildsPlan.new.build(name, options)
-    surgeon = ChoosesSurgeon.new.choose(plan)
-    PerformsSurgery.new.perform(plan, surgeon)
-  end
-
-  def self.verify(name, options)
-    test_plan = Suture::PrescribesTestPlan.new.prescribe(name, options)
-    test_results = Suture::TestsPatient.new.test(test_plan)
-    if test_results.failed?
-      Suture::InterpretsResults.new.interpret(test_plan, test_results)
-    end
-  end
-
-  def self.delete(id, options = {})
-    plan = BuildsPlan.new.build(name, options)
-    Suture::Adapter::Dictaphone.new(plan).delete(id)
-  end
-
-  def self.config(config = {})
-    @config ||= DEFAULT_OPTIONS.dup
-    @config.merge!(config)
-  end
-
-  def self.reset!
-    @config = nil
-    Adapter::Log.reset!
-  end
-end

data/suture.gemspec

@@ -26,10 +26,13 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry", "~> 0.9.12.6"
   spec.add_development_dependency "minitest", "~> 5.9"
   spec.add_development_dependency "gimme", "~> 0.5"
-  spec.add_development_dependency "github_changelog_generator"
 
   if Gem.ruby_version >= Gem::Version.new("1.9.3")
     spec.add_development_dependency "codeclimate-test-reporter"
     spec.add_development_dependency "simplecov", "~> 0.11.2" #<--only here to lock
   end
+
+  if Gem.ruby_version >= Gem::Version.new("2.2.2")
+    spec.add_development_dependency "github_changelog_generator"
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: suture
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Justin Searls
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-23 00:00:00.000000000 Z
+date: 2016-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.5'
 - !ruby/object:Gem::Dependency
-  name: github_changelog_generator
+  name: codeclimate-test-reporter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -123,33 +123,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.11.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.11.2
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: github_changelog_generator
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.2
+        version: '0'
 description: Provides tools to record calls to legacy code and verify new implementations
   still work
 email:
@@ -173,25 +173,36 @@ files:
 - lib/suture.rb
 - lib/suture/adapter/dictaphone.rb
 - lib/suture/adapter/log.rb
-- lib/suture/builds_plan.rb
-- lib/suture/chooses_surgeon.rb
 - lib/suture/comparator.rb
+- lib/suture/config.rb
+- lib/suture/create.rb
+- lib/suture/create/builds_plan.rb
+- lib/suture/create/chooses_surgeon.rb
+- lib/suture/create/performs_surgery.rb
+- lib/suture/create/validates_plan.rb
+- lib/suture/delete.rb
+- lib/suture/error/invalid_plan.rb
 - lib/suture/error/observation_conflict.rb
+- lib/suture/error/result_mismatch.rb
 - lib/suture/error/schema_version.rb
 - lib/suture/error/verification_failed.rb
-- lib/suture/interprets_results.rb
-- lib/suture/performs_surgery.rb
-- lib/suture/prescribes_test_plan.rb
+- lib/suture/reset.rb
+- lib/suture/surgeon/auditor.rb
 - lib/suture/surgeon/no_op.rb
 - lib/suture/surgeon/observer.rb
-- lib/suture/tests_patient.rb
+- lib/suture/surgeon/remediator.rb
 - lib/suture/util/env.rb
+- lib/suture/util/scalpel.rb
 - lib/suture/util/shuffle.rb
 - lib/suture/util/timer.rb
 - lib/suture/value/observation.rb
 - lib/suture/value/plan.rb
 - lib/suture/value/test_plan.rb
 - lib/suture/value/test_results.rb
+- lib/suture/verify.rb
+- lib/suture/verify/interprets_results.rb
+- lib/suture/verify/prescribes_test_plan.rb
+- lib/suture/verify/tests_patient.rb
 - lib/suture/version.rb
 - lib/suture/wrap/logger.rb
 - lib/suture/wrap/sqlite.rb