suture 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f33e4939ed0c1027f6785cc54be152ea672ebdb4
-  data.tar.gz: bec9bab57ef345f7095cabf4ece4c84e242b79e1
+SHA256:
+  metadata.gz: 1326f7c00beb85b3516536b4a7c04783360dde2a15af83be7434201a112967b6
+  data.tar.gz: e099889a2efeccbafe0ef83733bd9b3488b6ec7c6e2eed43d2e640a09c0f0650
 SHA512:
-  metadata.gz: 6ddae427868b0b514a8d4b6c3b413f0185c15321e5cfd0acea5ed044a60d78c5232dba4b4cbb3219b33abca7bfad9350a85aff05849f97dc8f1215d341b650f1
-  data.tar.gz: 15ef4a1b3af52821d69f1c3aa6997b123bcbcdc0570ce6296cf420caf7437f64083a4442bc278427ccb302fb806705faba8acf2ca0c531cac20450fbaf3c2fb7
+  metadata.gz: f198879578e76762c39a27ee395efbff86038f1f6c746ded31f46436761db14053d7f4a7c09abb327c6d28f822fdfb2cdbbeb4da6f1f30912f568fd480c36a5e
+  data.tar.gz: 4d8ddf4805fbe995f7c5a45cc1e64649f70c64e441127c2b2d9b0f2dccec9b8009529e9a49f6348e2ef94c0a23d71a9a3bae178d66bdf33401295284cab12eff

data/.github/workflows/main.yml

@@ -0,0 +1,31 @@
+name: Ruby
+
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Ruby ${{ matrix.ruby }}
+    strategy:
+      matrix:
+        ruby:
+          - '3.2'
+          - '3.3'
+          - '3.4'
+          - '4.0'
+
+    steps:
+    - uses: actions/checkout@v7
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - name: Run tests
+      run: bundle exec rake
+

data/.gitignore

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

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/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Change Log
 
+## [v1.2.0](https://github.com/testdouble/suture/tree/v1.2.0) (2026-09-18)
+[Full Changelog](https://github.com/testdouble/suture/compare/v1.1.2...v1.2.0)
+
+**Implemented enhancements:**
+
+- Add support for Ruby 3.4 and 4.0, including fixes for missing stdlib gem dependencies
+
+## [v1.1.2](https://github.com/testdouble/suture/tree/v1.1.2) (2018-11-12)
+[Full Changelog](https://github.com/testdouble/suture/compare/v1.1.1...v1.1.2)
+
+**Closed issues:**
+
+- task to explode tests from recorded suture data? [\#69](https://github.com/testdouble/suture/issues/69)
+
+**Merged pull requests:**
+
+- Standardize [\#71](https://github.com/testdouble/suture/pull/71) ([searls](https://github.com/searls))
+- Fix couple typos in README.md [\#70](https://github.com/testdouble/suture/pull/70) ([sharipov-ru](https://github.com/sharipov-ru))
+- Make minor sentence changes to the README [\#66](https://github.com/testdouble/suture/pull/66) ([alexcameron89](https://github.com/alexcameron89))
+- Add a Docker image [\#58](https://github.com/testdouble/suture/pull/58) ([seeflanigan](https://github.com/seeflanigan))
+
+## [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)
 
@@ -111,6 +143,3 @@
 - Create/Initialize a sqlite database [\#2](https://github.com/testdouble/suture/issues/2)
 - Create a new Suture [\#1](https://github.com/testdouble/suture/issues/1)
 
-
-
-\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

data/Gemfile

@@ -1,4 +1,12 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in suture.gemspec
 gemspec
+
+gem "rake"
+gem "tldr"
+gem "gimme"
+gem "standard"
+gem "ostruct"
+gem "logger"
+gem "irb"

data/Gemfile.lock

@@ -0,0 +1,120 @@
+PATH
+  remote: .
+  specs:
+    suture (1.2.0)
+      backports
+      bar-of-progress (>= 0.1.3)
+      bigdecimal
+      sqlite3
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    attr_extras (7.1.0)
+    backports (3.24.1)
+    bar-of-progress (0.1.3)
+    base64 (0.1.1)
+    bigdecimal (4.1.3)
+    concurrent-ruby (1.3.8)
+    diff-lcs (1.5.0)
+    erb (6.0.7)
+    gimme (0.5.0)
+    io-console (0.9.4)
+    irb (1.18.0)
+      pp (>= 0.6.0)
+      prism (>= 1.3.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    optimist (3.1.0)
+    ostruct (0.6.3)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    patience_diff (1.2.0)
+      optimist (~> 3.0)
+    pp (0.6.4)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.9.0)
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    rbs (4.1.3)
+      logger
+      prism (>= 1.6.0)
+      tsort
+    rdoc (8.0.0)
+      erb
+      prism (>= 1.6.0)
+      rbs (>= 4.0.0)
+      tsort
+    regexp_parser (2.8.1)
+    reline (0.7.0)
+      io-console (~> 0.5)
+    rexml (3.4.4)
+    rubocop (1.56.4)
+      base64 (~> 0.1.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-performance (1.19.1)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.13.0)
+    sqlite3 (2.9.6-arm64-darwin)
+    sqlite3 (2.9.6-x86_64-linux-gnu)
+    standard (1.31.1)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.56.2)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.2)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.2.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.19.0)
+    super_diff (0.10.0)
+      attr_extras (>= 6.2.4)
+      diff-lcs
+      patience_diff
+    tldr (0.6.0)
+      concurrent-ruby (~> 1.2)
+      super_diff (~> 0.10)
+    tsort (0.2.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  arm64-darwin-22
+  arm64-darwin-24
+  arm64-darwin-25
+  x86_64-linux
+
+DEPENDENCIES
+  gimme
+  irb
+  logger
+  ostruct
+  rake
+  standard
+  suture!
+  tldr
+
+BUNDLED WITH
+  4.0.20

data/README.md

@@ -1,6 +1,6 @@
 # Suture 🏥
 
-[![Build Status](https://travis-ci.org/testdouble/suture.svg?branch=master)](https://travis-ci.org/testdouble/suture) [![Code Climate](https://codeclimate.com/github/testdouble/suture/badges/gpa.svg)](https://codeclimate.com/github/testdouble/suture) [![Test Coverage](https://codeclimate.com/github/testdouble/suture/badges/coverage.svg)](https://codeclimate.com/github/testdouble/suture/coverage)
+[![Build Status](https://travis-ci.org/testdouble/suture.svg?branch=main)](https://travis-ci.org/testdouble/suture) [![Code Climate](https://codeclimate.com/github/testdouble/suture/badges/gpa.svg)](https://codeclimate.com/github/testdouble/suture) [![Test Coverage](https://codeclimate.com/github/testdouble/suture/badges/coverage.svg)](https://codeclimate.com/github/testdouble/suture/coverage)
 
 A refactoring tool for Ruby, designed to make it safe to change code you don't
 confidently understand. In fact, changing untrustworthy code is so fraught,
@@ -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 one approach that 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.
+will 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

@@ -1,54 +1,21 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "tldr/rake"
 
-Rake::TestTask.new(:unit) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList['test/helper.rb', 'test/**/*_test.rb']
-end
+TLDR::Task.new(:name => :unit)
 
-Rake::TestTask.new(:safe) do |t|
-  t.libs << "safe"
-  t.libs << "lib"
-  t.test_files = FileList['safe/helper.rb', 'safe/**/*_test.rb']
-end
+TLDR::Task.new(:name => :safe, :config => TLDR::Config.new(
+  :parallel => false,
+  :load_paths => ["safe", "lib"],
+  :helper_paths => ["safe/helper.rb"],
+  :paths => FileList["safe/**/*_test.rb"]
+))
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  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'
-  ]
-end
+TLDR::Task.new(:name => :test, :config => TLDR::Config.new(
+  :load_paths => ["safe", "test", "lib"],
+  :helper_paths => ["test/helper.rb", "safe/helper.rb"],
+  :paths => FileList["test/**/*_test.rb", "safe/**/*_test.rb"]
+))
 
-task :example do
-  Dir.chdir("example/rails_app") do
-    passed = system <<-SH
-      BUNDLE_GEMFILE="$PWD/Gemfile" bundle install --quiet
-      BUNDLE_GEMFILE="$PWD/Gemfile" bundle exec rake suture
-    SH
-    if !passed
-      raise StandardError.new("Rails example failed!")
-    end
-  end
-end
-
-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:rubygem_push"].enhance([:changelog, :changelog_commit])
-end
-
-
-task :default => [:test, :example]
+require "standard/rake"
+task :default => [:test, :"standard:fix"]

data/bin/console

@@ -6,9 +6,5 @@ require "suture"
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
 require "irb"
 IRB.start

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

@@ -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/create/builds_plan.rb

@@ -4,15 +4,15 @@ require "suture/util/env"
 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]
+      :after_old, :on_new_error, :on_old_error,
+      :expected_error_types]
 
     def build(name, options = {})
       Value::Plan.new(
-        Suture.config.
-          merge(options).
-          merge(:name => name).
-          merge(Suture::Util::Env.to_map(UN_ENV_IABLE_OPTIONS))
+        Suture.config
+          .merge(options)
+          .merge(:name => name)
+          .merge(Suture::Util::Env.to_map(UN_ENV_IABLE_OPTIONS))
       )
     end
   end

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

@@ -13,10 +13,10 @@ module Suture
         :test => lambda { |name| name.to_s.size < 256 },
         :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) }`)"
-      }),
+      },
       :new => CALLABLE_VALIDATION,
       :comparator => CALLABLE_VALIDATION.merge(
         :message => "must respond to `call` (e.g. `MyComparator.new` or `->(recorded, actual) { recorded == actual }`)"
@@ -26,7 +26,7 @@ module Suture
     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,7 +96,7 @@ 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
@@ -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