suture 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f33e4939ed0c1027f6785cc54be152ea672ebdb4
-  data.tar.gz: bec9bab57ef345f7095cabf4ece4c84e242b79e1
+SHA256:
+  metadata.gz: 163a4b24e5b0e5a27e41455d0fab014c19e96d9e7abe9b5ebf35d984094fdb95
+  data.tar.gz: 6f5f28071fd9f3cb298fd16f7fe5ddf7b66e57941792b6e0142daeffb2965677
 SHA512:
-  metadata.gz: 6ddae427868b0b514a8d4b6c3b413f0185c15321e5cfd0acea5ed044a60d78c5232dba4b4cbb3219b33abca7bfad9350a85aff05849f97dc8f1215d341b650f1
-  data.tar.gz: 15ef4a1b3af52821d69f1c3aa6997b123bcbcdc0570ce6296cf420caf7437f64083a4442bc278427ccb302fb806705faba8acf2ca0c531cac20450fbaf3c2fb7
+  metadata.gz: e8d2bef6ec660786f4b3da2722c0e95b722e7f456ce4347da9e6e36627eff99446c5280d708a2c2b639d1543dfd1ddaa0ebb7c4a0cf7a101e9295eaef49063c7
+  data.tar.gz: dd00faab3aca2bff8fe346170d0a31d2e80ecaf0a08ee7b2794900f25ef7a48b4db542b8a0c38e4fda21ad3c052d5638d555560a971d8a48149617a38349b172

data/.gitignore

@@ -1,5 +1,6 @@
 /.bundle/
 /.yardoc
+/Dockerfile
 /Gemfile.lock
 /_yardoc/
 /coverage/

data/.standard.yml

@@ -0,0 +1,7 @@
+ruby_version: 1.8.7
+
+ignore:
+  - "{safe,test}/**/*":
+    - Style/Semicolon
+  - "safe/fixtures/gilded_rose.rb"
+  - "example/rails_app/app/**/*"

data/.travis.yml

@@ -1,15 +1,17 @@
 language: ruby
 sudo: false
-before_install:
-  - gem install bundler
-  - cd example/rails_app && ./script/setup.sh && cd ../..
 rvm:
   - 1.8.7
   - 1.9
   - 2.0
   - 2.1
   - 2.2
-  - 2.3.1
+  - 2.3.3
+before_install:
+  - gem install bundler
+  - cd example/rails_app && ./script/setup.sh && cd ../..
+after_success:
+  - bundle exec codeclimate-test-reporter
 addons:
   code_climate:
     repo_token: 05e3e31164d59aa626b730b92eb9b7418326dbf23420a4b87eab2555840b39ef

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Change Log
 
+## [v1.1.1](https://github.com/testdouble/suture/tree/v1.1.1) (2016-09-19)
+[Full Changelog](https://github.com/testdouble/suture/compare/v1.1.0...v1.1.1)
+
+**Closed issues:**
+
+- call\_both: if raise\_on\_result\_mismatch is false and return\_old\_on\_result\_mismatch is true, rescue errors from :new path [\#64](https://github.com/testdouble/suture/issues/64)
+
+**Merged pull requests:**
+
+- Allow graceful fallback by call\_both when new code path raises [\#65](https://github.com/testdouble/suture/pull/65) ([searls](https://github.com/searls))
+
 ## [v1.1.0](https://github.com/testdouble/suture/tree/v1.1.0) (2016-09-18)
 [Full Changelog](https://github.com/testdouble/suture/compare/v1.0.0...v1.1.0)
 

data/Gemfile

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

data/README.md

@@ -9,11 +9,21 @@ Suture hopes to make it safer to completely reimplement a code path.
 Suture provides help to the entire lifecycle of refactoring poorly-understood
 code, from local development, to a staging environment, and even in production.
 
+# Video
+
+Suture was unveiled at Ruby Kaigi 2016 as a one approach that we can make
+refactors less scary and more predictable. You can watch the 45 minute screencast
+here:
+
+[<img width="803" alt="screen shot 2016-09-20 at 9 44 43 am" src="https://cloud.githubusercontent.com/assets/79303/18653743/e669d304-7f16-11e6-84e7-c86b8f88132c.png" alt="A presentation on Suture">](http://blog.testdouble.com/posts/2016-09-16-surgical-refactors-with-suture.html)
+
+# Walk-through guide
+
 Refactoring or reimplementing important code is an involved process! Instead of
 listing out Suture's API without sufficient exposition, here is an example that
 we'll take you through each stage of the lifecycle.
 
-## development
+## Development
 
 Suppose you have a really nasty worker method:
 
@@ -58,9 +68,12 @@ class LegacyWorker
 end
 ```
 
-As you can see, the call to `MyMailer.send` is left at the original call site,
-since its effectively a void method being invoked for its side effect, and its
-much easier to verify return values.
+As you can see, the call to `MyMailer.send` is left at the original call site.
+`MyMailer.send` is effectively a void method being invoked for its side effect,
+which would make it difficult to test. By creating `LegacyWorker#call`, we can
+now express the work more clearly in terms of repeatable inputs (`id`) and
+outputs (`thing.result`), which will help us verify that our refactor is working
+later.
 
 Since any changes to the code while it's untested are very dangerous, it's
 important to minimize changes made for the sake of creating a clear seam.
@@ -89,10 +102,10 @@ LegacyWorker without taking any other meaningful action.
 
 ### 3. Record the current behavior
 
-Next, we want to start observing how the legacy worker is actually called: what
-arguments are sent to it and what values does it return? By recording the calls
-as we use our app locally, we can later test that the old and new
-implementations behave the same way.
+Next, we want to start observing how the legacy worker is actually called. What
+arguments are being sent to it and what value does it returns (or, what error
+does it raise)? By recording the calls as we use our app locally, we can later
+test that the old and new implementations behave the same way.
 
 First, we tell Suture to start recording calls by setting the environment
 variable `SUTURE_RECORD_CALLS` to something truthy (e.g.
@@ -101,8 +114,8 @@ any calls to our seam will record the arguments passed to the legacy code path
 and the return value.
 
 As you use the application (whether it's a queue system, a web app, or a CLI),
-the calls will be saved to a sqlite database. If the legacy code path relies on
-external data sources or services, keep in mind that your recorded inputs and
+the calls will be saved to a sqlite database. Keep in mind that if the legacy code
+path relies on external data sources or services, your recorded inputs and
 outputs will rely on them as well. You may want to narrow the scope of your
 seam accordingly (e.g. to receive an object as an argument instead of a database
 id).
@@ -146,7 +159,7 @@ expected value. It's a good idea to run this against the legacy code first,
 for two reasons:
 
 * running the characterization tests against the legacy code path will ensure
-the test environment has the data needed to behave the same way as when it was
+that the test environment has the data needed to behave the same way as when it was
 recorded (it may be appropriate to take a snapshot of the database before you
 start recording and load it before you run your tests)
 
@@ -158,13 +171,13 @@ start recording and load it before you run your tests)
   subordinate to it) to make sure our characterization test sufficiently
   exercises it
   * identify incidental coverage of code paths that are outside the scope of
-  what we hope to refactor, and in turn analyzing whether `LegacyWorker` has
+  what we hope to refactor. This will help to see if `LegacyWorker` has
   side effects we didn't anticipate and should additionally write tests for
 
 ### 5. Specify and test a path for new code
 
-Once our automated characterization test of our recordings is passing, then we
-can start work on a `NewWorker`. To get started, we can update our Suture
+Once the automated characterization test of our recordings is passing, then we
+can start work on a `NewWorker`. To get started, we update our Suture
 configuration:
 
 ``` ruby
@@ -214,7 +227,7 @@ end
 ```
 
 Obviously, this should fail until `NewWorker`'s implementation covers all the
-cases we recorded from `LegacyWorker`.
+cases that we recorded from `LegacyWorker`.
 
 Remember, characterization tests aren't designed to be kept around forever. Once
 you're confident that the new implementation is sufficient, it's typically better
@@ -225,21 +238,21 @@ implementation and its component parts.
 
 This step is the hardest part and there's not much Suture can do to make it
 any easier. How you go about implementing your improvements depends on whether
-you intend to rewrite the legacy code path or refactor it. Some comment on each
-approach follows:
+you intend to rewrite the legacy code path or refactor it. Some comments on each
+approach follow:
 
 #### Reimplementing
 
 The best time to rewrite a piece of software is when you have a better
-understanding of the real-world process it models than the original authors did
+understanding of the real-world process that it models than the original authors did
 when they first wrote it. If that's the case, it's likely you'll think of more
 reliable names and abstractions than they did.
 
 As for workflow, consider writing the new implementation like you would any other
-new part of the system, with the added benefit of being able to run the
+new part of the system. The added benefit is being able to run the
 characterization tests as a progress indicator and a backstop for any missed edge
 cases. The ultimate goal of this workflow should be to incrementally arrive at a
-clean design that completely passes the characterization test run by
+clean design that completely passes the characterization test run by running
 `Suture.verify`.
 
 #### Refactoring
@@ -323,7 +336,7 @@ Suture.config({
 ```
 
 When your new code path raises an error with the above settings, it will
-propogate and log the error to the specified file.
+propagate and log the error to the specified file.
 
 ### Custom error handlers
 
@@ -478,7 +491,7 @@ certain cases, setting `:expected_error_types => [WidgetError]` will result in:
     `kind_of?` any recorded error type (regardless of whether `Suture.verify` is
     passed a redundant list of `expected_error_types`)
   * `Suture.create`, when `fallback_on_error` is enabled, will allow expected
-    errors raised by the `new` path to propogate, as opposed to logging &
+    errors raised by the `new` path to propagate, as opposed to logging &
     rescuing them before calling the `old` path as a fallback
 
 * _disable_ - (Default: `false`) - when enabled, Suture will attempt to revert to
@@ -641,7 +654,7 @@ detects two ActiveRecord model instances being compared, it will behave
 differently, by this logic:
 
 1. Instead of comparing the objects with `==` (which returns true so long as the
-`id` attribute matdhes), Suture will compare the objects' `attributes` hashes
+`id` attribute matches), Suture will compare the objects' `attributes` hashes
 instead
 2. The built-in `updated_at` and `created_at` will typically differ when code
 is executed at different times and are usually not meaningful to application

data/Rakefile

@@ -4,13 +4,13 @@ require "rake/testtask"
 Rake::TestTask.new(:unit) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList['test/helper.rb', 'test/**/*_test.rb']
+  t.test_files = FileList["test/helper.rb", "test/**/*_test.rb"]
 end
 
 Rake::TestTask.new(:safe) do |t|
   t.libs << "safe"
   t.libs << "lib"
-  t.test_files = FileList['safe/helper.rb', 'safe/**/*_test.rb']
+  t.test_files = FileList["safe/helper.rb", "safe/**/*_test.rb"]
 end
 
 Rake::TestTask.new(:test) do |t|
@@ -18,11 +18,11 @@ Rake::TestTask.new(:test) do |t|
   t.libs << "safe"
   t.libs << "lib"
   t.test_files = FileList[
-    'safe/support/code_climate',
-    'test/helper.rb',
-    'test/**/*_test.rb',
-    'safe/helper.rb',
-    'safe/**/*_test.rb'
+    "safe/support/code_climate",
+    "test/helper.rb",
+    "test/**/*_test.rb",
+    "safe/helper.rb",
+    "safe/**/*_test.rb"
   ]
 end
 
@@ -32,14 +32,14 @@ task :example do
       BUNDLE_GEMFILE="$PWD/Gemfile" bundle install --quiet
       BUNDLE_GEMFILE="$PWD/Gemfile" bundle exec rake suture
     SH
-    if !passed
-      raise StandardError.new("Rails example failed!")
+    unless passed
+      raise StandardError, "Rails example failed!"
     end
   end
 end
 
 if Gem.ruby_version >= Gem::Version.new("2.2.2")
-  require 'github_changelog_generator/task'
+  require "github_changelog_generator/task"
   GitHubChangelogGenerator::RakeTask.new :changelog
   task :changelog_commit do
     require "suture"
@@ -50,5 +50,4 @@ if Gem.ruby_version >= Gem::Version.new("2.2.2")
   Rake::Task["release:rubygem_push"].enhance([:changelog, :changelog_commit])
 end
 
-
 task :default => [:test, :example]

data/lib/suture.rb

@@ -5,4 +5,3 @@ require "suture/verify"
 require "suture/delete"
 require "suture/config"
 require "suture/reset"
-

data/lib/suture/adapter/dictaphone.rb

@@ -19,7 +19,6 @@ module Suture::Adapter
       end
     end
 
-
     def record(returned_value)
       record_result(Suture::Value::Result.returned(returned_value))
     end
@@ -48,7 +47,7 @@ module Suture::Adapter
       Suture::Wrap::Sqlite.delete(@db, :observations, "where name = ?", [name.to_s])
     end
 
-  private
+    private
 
     def record_result(result)
       Suture::Wrap::Sqlite.insert(

data/lib/suture/comparator.rb

@@ -7,7 +7,7 @@ module Suture
         :active_record_excluded_attributes => (
           options[:active_record_excluded_attributes] ||
             DEFAULT_ACTIVE_RECORD_EXCLUDED_ATTRIBUTES
-        ).map(&:to_s)
+        ).map(&:to_s),
       }
     end
 
@@ -23,7 +23,7 @@ module Suture
     protected
 
     def compare_active_record(recorded, actual)
-      actual.kind_of?(recorded.class) &&
+      actual.is_a?(recorded.class) &&
         without_excluded_attrs(recorded.attributes) ==
           without_excluded_attrs(actual.attributes)
     end
@@ -31,7 +31,7 @@ module Suture
     private
 
     def without_excluded_attrs(hash)
-      hash.reject do |k, v|
+      hash.reject do |k, _v|
         @options[:active_record_excluded_attributes].include?(k.to_s)
       end
     end
@@ -46,8 +46,8 @@ module Suture
 
     def is_active_record?(recorded, actual)
       defined?(ActiveRecord::Base) &&
-        recorded.kind_of?(ActiveRecord::Base) &&
-        actual.kind_of?(ActiveRecord::Base)
+        recorded.is_a?(ActiveRecord::Base) &&
+        actual.is_a?(ActiveRecord::Base)
     end
   end
 end

data/lib/suture/config.rb

@@ -8,7 +8,7 @@ module Suture
     :log_stdout => true,
     :log_io => nil,
     :log_file => nil,
-    :raise_on_result_mismatch => true
+    :raise_on_result_mismatch => true,
   }
 
   def self.config(config = {})

data/lib/suture/create/builds_plan.rb

@@ -5,7 +5,7 @@ module Suture
   class BuildsPlan
     UN_ENV_IABLE_OPTIONS = [:name, :old, :new, :args, :comparator, :after_new,
                             :after_old, :on_new_error, :on_old_error,
-                            :expected_error_types]
+                            :expected_error_types,]
 
     def build(name, options = {})
       Value::Plan.new(

data/lib/suture/create/chooses_surgeon.rb

@@ -12,7 +12,7 @@ module Suture
       return Surgeon::NoOp.new if plan.disable
       if plan.record_calls
         if plan.new
-          log_warn <<-MSG.gsub(/^ {12}/,'')
+          log_warn <<-MSG.gsub(/^ {12}/, "")
             Seam #{plan.name.inspect} has a :new code path defined, but because
             it is set to :record_calls, we will invoke the :old code path
             instead. If this is not what you intend, set :record_calls to false.

data/lib/suture/create/validates_plan.rb

@@ -5,28 +5,28 @@ module Suture
     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)"
+      :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"
+        :message => "must be less than 256 characters",
       },
-      :old => CALLABLE_VALIDATION = ({
+      :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) }`)"
-      }),
+        :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
-          <<-MSG.gsub(/^ {12}/,'')
+          <<-MSG.gsub(/^ {12}/, "")
             :record_calls is enabled, but :database_path is nil, so Suture
               doesn't know where to record calls to the seam.
           MSG
@@ -34,7 +34,7 @@ module Suture
       },
       lambda { |plan|
         if plan.record_calls && plan.call_both
-          <<-MSG.gsub(/^ {12}/,'')
+          <<-MSG.gsub(/^ {12}/, "")
             :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
@@ -51,7 +51,7 @@ module Suture
       },
       lambda { |plan|
         if plan.record_calls && plan.fallback_on_error
-          <<-MSG.gsub(/^ {12}/,'')
+          <<-MSG.gsub(/^ {12}/, "")
             :record_calls & :fallback_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
@@ -63,7 +63,7 @@ module Suture
       },
       lambda { |plan|
         if plan.call_both && plan.fallback_on_error
-          <<-MSG.gsub(/^ {12}/,'')
+          <<-MSG.gsub(/^ {12}/, "")
             :call_both & :fallback_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
@@ -75,7 +75,7 @@ module Suture
       },
       lambda { |plan|
         if plan.call_both && !plan.new.respond_to?(:call)
-          <<-MSG.gsub(/^ {12}/,'')
+          <<-MSG.gsub(/^ {12}/, "")
             :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
@@ -84,7 +84,7 @@ module Suture
       },
       lambda { |plan|
         if plan.fallback_on_error && !plan.new.respond_to?(:call)
-          <<-MSG.gsub(/^ {12}/,'')
+          <<-MSG.gsub(/^ {12}/, "")
             :fallback_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
@@ -96,13 +96,13 @@ module Suture
       },
       lambda { |plan|
         if !plan.raise_on_result_mismatch && !plan.call_both
-          <<-MSG.gsub(/^ {12}/,'')
+          <<-MSG.gsub(/^ {12}/, "")
             :raise_on_result_mismatch was disabled but :call_both is not enabled.
               This option only applies to the :call_both mode, and will have no
               impact when set for other modes
           MSG
         end
-      }
+      },
     ]
 
     def validate(plan)
@@ -125,7 +125,7 @@ module Suture
 
     def invalid_attrs(plan)
       VALIDATIONS.select { |name, rule|
-        next unless attr = plan.send(name)
+        next unless (attr = plan.send(name))
         !rule[:test].call(attr)
       }
     end

data/lib/suture/error/invalid_plan.rb

@@ -3,31 +3,31 @@ module Suture::Error
     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}/,'')
+      new <<-MSG.gsub(/^ {8}/, "")
         #{HEADER}
 
         The following options are required:
 
-          #{requirements.map {|(name,explanation)|
+          #{requirements.map {|(name, explanation)|
               "* #{name.inspect} - #{explanation}"
             }.join("\n  ")}
       MSG
     end
 
     def self.invalid_options(invalids)
-      new <<-MSG.gsub(/^ {8}/,'')
+      new <<-MSG.gsub(/^ {8}/, "")
         #{HEADER}
 
         The following options were invalid:
 
-          #{invalids.map {|(name,rule)|
+          #{invalids.map {|(name, rule)|
               "* #{name.inspect} - #{rule[:message]}"
             }.join("\n  ")}
       MSG
     end
 
     def self.conflicting_options(conflicts)
-      new <<-MSG.gsub(/^ {8}/,'')
+      new <<-MSG.gsub(/^ {8}/, "")
         #{HEADER}
 
         Suture isn't sure how to best handle the combination of options passed:

data/lib/suture/error/observation_conflict.rb

@@ -9,7 +9,7 @@ module Suture::Error
     end
 
     def message
-      <<-MSG.gsub(/^ {8}/,'')
+      <<-MSG.gsub(/^ {8}/, "")
         At seam #{@name.inspect}, we just recorded a duplicate call, but the same arguments
         resulted in a different output. Read on for details:
 

data/lib/suture/error/result_mismatch.rb

@@ -7,7 +7,7 @@ module Suture::Error
     end
 
     def message
-      <<-MSG.gsub(/^ {8}/,'')
+      <<-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

data/lib/suture/error/verification_failed.rb

@@ -14,7 +14,7 @@ module Suture::Error
         describe_failures(@results.failed, @plan),
         configuration(@plan),
         summarize(@results),
-        progress(@plan, @results)
+        progress(@plan, @results),
       ].compact.join("\n").tap do
       end
     end
@@ -22,7 +22,7 @@ module Suture::Error
     private
 
     def intro
-      <<-MSG.gsub(/^ {8}/,'')
+      <<-MSG.gsub(/^ {8}/, "")
 
         # Verification of your seam failed!
 
@@ -31,7 +31,7 @@ module Suture::Error
     end
 
     def summarize(results)
-      <<-MSG.gsub(/^ {8}/,'')
+      <<-MSG.gsub(/^ {8}/, "")
         # Result Summary
 
           - Passed........#{results.passed_count}
@@ -49,7 +49,7 @@ module Suture::Error
         results.all.size
       )
       percent = Suture::Util::Numbers.percent(results.passed.size, results.all.size)
-      <<-MSG.gsub(/^ {8}/,'')
+      <<-MSG.gsub(/^ {8}/, "")
         ## Progress
 
         Here's what your progress to initial completion looks like so far:
@@ -61,7 +61,7 @@ module Suture::Error
     end
 
     def configuration(plan)
-      <<-MSG.gsub(/^ {8}/,'')
+      <<-MSG.gsub(/^ {8}/, "")
         # Configuration
 
         This is the configuration used by this test run:
@@ -81,7 +81,7 @@ module Suture::Error
     end
 
     def describe_comparator(comparator)
-      if comparator.kind_of?(Proc)
+      if comparator.is_a?(Proc)
         "Proc # (in: `#{describe_source_location(*comparator.source_location)}`)"
       elsif comparator.respond_to?(:method) && comparator.method(:call)
         "#{comparator.inspect}.new, # (in: `#{describe_source_location(*comparator.method(:call).source_location)}`)"
@@ -90,7 +90,7 @@ module Suture::Error
 
     def describe_source_location(file, line)
       root = File.join(Dir.getwd, "/")
-      path = file.start_with?(root) ? file.gsub(root, '') : file
+      path = file.start_with?(root) ? file.gsub(root, "") : file
       "#{path}:#{line}"
     end
 
@@ -102,13 +102,13 @@ module Suture::Error
           describe_failure(failure, index) if plan.error_message_limit.nil? || index < plan.error_message_limit
         },
         describe_squelched_failure_messages(failures.size, plan.error_message_limit),
-        describe_general_failure_advice(plan)
+        describe_general_failure_advice(plan),
       ].flatten.compact.join("\n")
     end
 
     def describe_failure(failure, index)
       expected = failure[:observation]
-      return <<-MSG.gsub(/^ {8}/,'')
+      <<-MSG.gsub(/^ {8}/, "")
         #{index + 1}.) Recorded call for seam #{expected.name.inspect} (ID: #{expected.id}) ran and #{failure[:error] ? "raised an error" : "failed comparison"}.
 
           Arguments: ```
@@ -117,13 +117,12 @@ module Suture::Error
           Expected #{expected.result.errored? ? "error raised" : "returned value"}: ```
             #{expected.result.value.inspect}
           ```
-          Actual #{(failure[:error] || failure[:new_result].errored?) ? "error raised" : "returned value"}: ```
+          Actual #{failure[:error] || failure[:new_result].errored? ? "error raised" : "returned value"}: ```
             #{if failure[:error]
                 stringify_error(failure[:error])
               else
                 failure[:new_result].value.inspect
-              end
-            }
+              end}
           ```
 
           Ideas to fix this:
@@ -138,7 +137,7 @@ module Suture::Error
     end
 
     def describe_general_failure_advice(plan)
-      <<-MSG.gsub(/^ {8}/,'')
+      <<-MSG.gsub(/^ {8}/, "")
         ### Fixing these failures
 
         #### Custom comparator
@@ -156,7 +155,7 @@ module Suture::Error
         behavior somewhere in your subject's code.
 
         #{if !plan.random_seed.nil?
-            <<-MOAR.gsub(/^ {14}/,'')
+            <<-MOAR.gsub(/^ {14}/, "")
               To re-run the tests with the same random seed as was used in this run,
               set the env var `SUTURE_RANDOM_SEED=#{plan.random_seed}` or the config entry
               `:random_seed => #{plan.random_seed}`.
@@ -167,7 +166,7 @@ module Suture::Error
               `:random_seed => nil`.
             MOAR
           else
-            <<-MOAR.gsub(/^ {14}/,'')
+            <<-MOAR.gsub(/^ {14}/, "")
               This test was run in insertion order (by the primary key of the table
               that stores calls, ascending). This is sometimes necessary when the
               code has an order-dependent side effect, but shouldn't be set unless it's
@@ -180,7 +179,6 @@ module Suture::Error
       MSG
     end
 
-
     def stringify_error(error)
       s = error.inspect
       s += "\n" + error.backtrace.join("\n") if error.backtrace

data/lib/suture/reset.rb

@@ -6,4 +6,3 @@ module Suture
     Adapter::Log.reset!
   end
 end
-

data/lib/suture/surgeon/auditor.rb

@@ -24,11 +24,9 @@ module Suture::Surgeon
     private
 
     def result_for(plan, path)
-      begin
-        Suture::Value::Result.returned(@scalpel.cut(plan, path))
-      rescue StandardError => error
-        Suture::Value::Result.errored(error)
-      end
+      Suture::Value::Result.returned(@scalpel.cut(plan, path))
+    rescue => error
+      Suture::Value::Result.errored(error)
     end
 
     def comparable?(plan, old_result, new_result)
@@ -53,12 +51,12 @@ module Suture::Surgeon
       if result.errored?
         raise result.value
       else
-        return result.value
+        result.value
       end
     end
 
     def log_warning(plan, old_result, new_result)
-      log_warn <<-MSG.gsub(/^ {8}/,'')
+      log_warn <<-MSG.gsub(/^ {8}/, "")
         Seam #{plan.name.inspect} is set to :call_both the :new and :old code
         paths, but they did not match.
 

data/lib/suture/surgeon/no_op.rb

@@ -3,7 +3,7 @@ require "suture/util/scalpel"
 module Suture::Surgeon
   class NoOp
     def operate(plan)
-      if code_path = code_path_for(plan)
+      if (code_path = code_path_for(plan))
         Suture::Util::Scalpel.new.cut(plan, code_path)
       end
     end

data/lib/suture/surgeon/observer.rb

@@ -9,8 +9,8 @@ module Suture::Surgeon
         Suture::Util::Scalpel.new.cut(plan, :old).tap do |result|
           dictaphone.record(result)
         end
-      rescue StandardError => error
-        if plan.expected_error_types.any? {|e| error.kind_of?(e) }
+      rescue => error
+        if plan.expected_error_types.any? {|e| error.is_a?(e) }
           dictaphone.record_error(error)
         end
         raise error
@@ -18,4 +18,3 @@ module Suture::Surgeon
     end
   end
 end
-

data/lib/suture/surgeon/remediator.rb

@@ -7,14 +7,12 @@ module Suture::Surgeon
     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
+      @scalpel.cut(plan, :new)
+    rescue => 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

data/lib/suture/util/compares_results.rb

@@ -8,7 +8,7 @@ module Suture::Util
       if expected.errored? != actual.errored?
         false
       elsif expected.errored?
-        actual.value.kind_of?(expected.value.class) &&
+        actual.value.is_a?(expected.value.class) &&
           expected.value.message == actual.value.message
       else
         @comparator.call(expected.value, actual.value)

data/lib/suture/util/env.rb

@@ -3,15 +3,15 @@ module Suture::Util
     def self.to_map(excludes = {})
       Hash[
         ENV.keys.
-            select { |k| k.start_with?("SUTURE_") }.
-            map { |k| [to_sym(k), sanitize_value(ENV[k])] }
-      ].reject { |(k,_)| excludes.include?(k) }
+          select { |k| k.start_with?("SUTURE_") }.
+          map { |k| [to_sym(k), sanitize_value(ENV[k])] }
+      ].reject { |(k, _)| excludes.include?(k) }
     end
 
     # private
 
     def self.to_sym(name)
-      name.gsub(/^SUTURE\_/,'').downcase.to_sym
+      name.gsub(/^SUTURE\_/, "").downcase.to_sym
     end
 
     def self.sanitize_value(value)

data/lib/suture/util/scalpel.rb

@@ -10,7 +10,7 @@ module Suture::Util
         plan.send(location).call(*args).tap do |result|
           call_after_hook(plan, location, args, result)
         end
-      rescue StandardError => error
+      rescue => error
         log_error_details(plan, location, args, error)
         call_error_hook(plan, location, args, error)
         raise error
@@ -20,13 +20,13 @@ module Suture::Util
     private
 
     def call_after_hook(plan, location, args, result)
-      return unless after_hook = try(plan, "after_#{location}")
+      return unless (after_hook = try(plan, "after_#{location}"))
       after_hook.call(args, result)
     end
 
     def log_error_details(plan, location, args, error)
       return if expected_error?(plan, error)
-      log_error <<-MSG.gsub(/^ {8}/,'')
+      log_error <<-MSG.gsub(/^ {8}/, "")
         Suture invoked the #{plan.name.inspect} seam's #{location.inspect} code path with args: ```
           #{args.inspect}
         ```
@@ -38,12 +38,12 @@ module Suture::Util
 
     def call_error_hook(plan, location, args, error)
       return if expected_error?(plan, error)
-      return unless error_hook = try(plan, "on_#{location}_error")
+      return unless (error_hook = try(plan, "on_#{location}_error"))
       error_hook.call(plan.name, args, error)
     end
 
     def expected_error?(plan, error)
-      plan.expected_error_types.any? {|e| error.kind_of?(e) }
+      plan.expected_error_types.any? {|e| error.is_a?(e) }
     end
 
     def args_for(plan, args_override)
@@ -62,6 +62,5 @@ module Suture::Util
       return unless plan.respond_to?(method)
       plan.send(method)
     end
-
   end
 end

data/lib/suture/util/shuffle.rb

@@ -7,7 +7,7 @@ module Suture::Util
         index = random.rand(old_array.size)
         new_array << old_array.delete_at(index)
       end
-      return new_array
+      new_array
     end
   end
 end

data/lib/suture/value/observation.rb

@@ -13,7 +13,7 @@ module Suture::Value
     end
 
     def result
-      @expectation ||= @error ? Result.errored(@error) : Result.returned(@return_value)
+      @result ||= @error ? Result.errored(@error) : Result.returned(@return_value)
     end
   end
 end

data/lib/suture/value/plan.rb

@@ -1,10 +1,10 @@
 module Suture::Value
   class Plan
     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,
-                :return_old_on_result_mismatch, :fallback_on_error,
-                :expected_error_types, :disable, :dup_args
+      :on_old_error, :database_path, :record_calls, :comparator,
+      :call_both, :raise_on_result_mismatch,
+      :return_old_on_result_mismatch, :fallback_on_error,
+      :expected_error_types, :disable, :dup_args
 
     def initialize(attrs = {})
       @name = attrs[:name]

data/lib/suture/value/result.rb

@@ -19,10 +19,10 @@ module Suture::Value
     end
 
     def ==(other)
-      other.kind_of?(self.class) && other.state == state
+      other.is_a?(self.class) && other.state == state
     end
 
-    alias_method :eql?, :==
+    alias eql? ==
 
     def hash
       state.hash

data/lib/suture/value/test_plan.rb

@@ -1,17 +1,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, :after_subject, :on_subject_error,
-                  :expected_error_types
+      :verify_only, :fail_fast, :call_limit, :time_limit,
+      :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, :comparator,
-                                  :database_path, :after_subject,
-                                  :on_subject_error)
+        :database_path, :after_subject,
+        :on_subject_error)
       assign_integral_ivars!(attrs, :verify_only, :call_limit, :time_limit,
-                                   :error_message_limit)
+        :error_message_limit)
       @fail_fast = !!attrs[:fail_fast]
       @expected_error_types = attrs[:expected_error_types] || []
       @random_seed = determine_random_seed(attrs)
@@ -26,18 +26,18 @@ module Suture::Value
     end
 
     def assign_integral_ivars!(attrs, *names)
-      assign_simple_ivars!(massage_values(attrs, names) {|v| v.to_i }, *names)
+      assign_simple_ivars!(massage_values(attrs, names, &:to_i), *names)
     end
 
-    def massage_values(attrs, names, &blk)
+    def massage_values(attrs, names)
       Hash[
-        attrs.select {|(k,_)| names.include?(k) }.
-              map { |(k,v)| [k, v.nil? ? nil : blk.call(v) ]}
+        attrs.select {|(k, _)| names.include?(k) }.
+          map { |(k, v)| [k, v.nil? ? nil : yield(v)]}
       ]
     end
 
     def determine_random_seed(attrs)
-      if attrs.has_key?(:random_seed)
+      if attrs.key?(:random_seed)
         if attrs[:random_seed].nil? || attrs[:random_seed] == "nil"
           nil
         else

data/lib/suture/value/test_results.rb

@@ -45,4 +45,3 @@ module Suture::Value
     end
   end
 end
-

data/lib/suture/verify.rb

@@ -11,4 +11,3 @@ module Suture
     end
   end
 end
-

data/lib/suture/verify/administers_test.rb

@@ -14,17 +14,17 @@ module Suture
         result = Value::Result.returned(@scalpel.cut(test_plan, :subject, observation.args))
         {
           :new_result => result,
-          :passed => compares_results.compare(observation.result, result)
+          :passed => compares_results.compare(observation.result, result),
         }
-      rescue StandardError => error
+      rescue => error
         if observation.result.errored?
           result = Value::Result.errored(error)
           {
             :new_result => result,
-            :passed => compares_results.compare(observation.result, result)
+            :passed => compares_results.compare(observation.result, result),
           }
         else
-          { :error => error, :passed => false }
+          {:error => error, :passed => false}
         end
       end
     end

data/lib/suture/verify/interprets_results.rb

@@ -8,5 +8,3 @@ module Suture
     end
   end
 end
-
-

data/lib/suture/verify/prescribes_test_plan.rb

@@ -4,7 +4,7 @@ require "suture/util/env"
 module Suture
   class PrescribesTestPlan
     UN_ENV_IABLE_OPTIONS = [:name, :subject, :comparator, :after_subject,
-                            :on_subject_error, :expected_error_types]
+                            :on_subject_error, :expected_error_types,]
 
     def prescribe(name, options = {})
       Value::TestPlan.new(Suture.config.

data/lib/suture/verify/tests_patient.rb

@@ -24,12 +24,12 @@ module Suture
         if should_skip?(test_plan, experienced_failure_in_life, i, timer)
           {
             :observation => observation,
-            :ran => false
+            :ran => false,
           }
         else
           @administers_test.administer(test_plan, observation).merge({
             :observation => observation,
-            :ran => true
+            :ran => true,
           }).tap { |r| experienced_failure_in_life = true unless r[:passed] }
         end
       })
@@ -39,7 +39,7 @@ module Suture
 
     def validate_test_plan!(test_plan)
       if !test_plan.subject || !test_plan.subject.respond_to?(:call)
-        raise Suture::Error::InvalidTestPlan.new
+        raise Suture::Error::InvalidTestPlan
       end
     end
 
@@ -56,7 +56,7 @@ module Suture
         test_plan.random_seed
       ).tap do |test_cases|
         next if test_cases.size > 0
-        log_warn <<-MSG.gsub(/^ {10}/,'')
+        log_warn <<-MSG.gsub(/^ {10}/, "")
           Suture.verify found no recorded calls for seam #{test_plan.name.inspect}.
           As a result, verify will have no effect and cannot provide any assurance
           that the subject is working as expected.
@@ -70,4 +70,3 @@ module Suture
     end
   end
 end
-

data/lib/suture/version.rb

@@ -1,3 +1,3 @@
 module Suture
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 end

data/lib/suture/wrap/logger.rb

@@ -12,12 +12,12 @@ module Suture::Wrap
       end
 
       @logger.level = if options[:log_level]
-                        ::Logger.const_get(options[:log_level])
-                      else
-                        ::Logger::INFO
-                      end
+        ::Logger.const_get(options[:log_level])
+      else
+        ::Logger::INFO
+      end
 
-      @logger.formatter = proc { |_, time , _, msg|
+      @logger.formatter = proc { |_, time, _, msg|
         formatted_time = time.strftime("%Y-%m-%dT%H:%M:%S.%6N")
         "[#{formatted_time}] Suture: #{msg}\n".tap { |out|
           puts out if options[:log_stdout]
@@ -25,19 +25,39 @@ module Suture::Wrap
         }
       }
 
-      return @logger
+      @logger
     end
 
     class NullIO
-      def gets; end
-      def each; end
-      def read(count=nil,buffer=nil); (count && count > 0) ? nil : ""; end
-      def rewind; 0; end
-      def close; end
-      def size; 0; end
-      def sync=(*args); end
-      def puts(*args); end
-      def write(*args); end
+      def gets
+      end
+
+      def each
+      end
+
+      def read(count = nil, _buffer = nil)
+        count && count > 0 ? nil : ""
+      end
+
+      def rewind
+        0
+      end
+
+      def close
+      end
+
+      def size
+        0
+      end
+
+      def sync=(*args)
+      end
+
+      def puts(*args)
+      end
+
+      def write(*args)
+      end
     end
   end
 end

data/lib/suture/wrap/sqlite.rb

@@ -4,7 +4,7 @@ require "suture/error/schema_version"
 
 module Suture::Wrap
   module Sqlite
-    SCHEMA_VERSION=2
+    SCHEMA_VERSION = 2
     def self.init(location)
       full_path = File.join(Dir.getwd, location)
       FileUtils.mkdir_p(File.dirname(full_path))

data/suture.gemspec

@@ -1,7 +1,8 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'suture/version'
+require "suture/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "suture"
@@ -9,8 +10,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Justin Searls"]
   spec.email         = ["searls@gmail.com"]
 
-  spec.summary       = %q{A gem that helps people refactor or reimplement legacy code}
-  spec.description   = %q{Provides tools to record calls to legacy code and verify new implementations still work}
+  spec.summary       = "A gem that helps people refactor or reimplement legacy code"
+  spec.description   = "Provides tools to record calls to legacy code and verify new implementations still work"
   spec.homepage      = "https://github.com/testdouble/suture"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(example|test|db|log|safe|spec|features)/}) }
@@ -30,7 +31,11 @@ Gem::Specification.new do |spec|
 
   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
+    spec.add_development_dependency "simplecov", "~> 0.11.2" # <--only here to lock
+  end
+
+  if Gem.ruby_version >= Gem::Version.new("2.2.0")
+    spec.add_development_dependency "standard"
   end
 
   if Gem.ruby_version >= Gem::Version.new("2.2.2")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: suture
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Justin Searls
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-19 00:00:00.000000000 Z
+date: 2018-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -150,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: standard
+  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: github_changelog_generator
   requirement: !ruby/object:Gem::Requirement
@@ -176,6 +190,7 @@ files:
 - ".gitignore"
 - ".projections.json"
 - ".rubocop.yml"
+- ".standard.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
@@ -246,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A gem that helps people refactor or reimplement legacy code