attestify 0.1.0.pre.2 → 0.1.0.pre.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 876c694bdaec5a2ae1048fc2a54b2d38b4251969
-  data.tar.gz: efc2a21cff2441ba14938aeac038f0d8912efbf5
+  metadata.gz: 7277786172463a5c2d2b1e37dcb5d9336e69465f
+  data.tar.gz: 3b2bdd5dbcf9cc1cad6d36f23fc2e13bce86e84d
 SHA512:
-  metadata.gz: 5db0a47826a1872993a5be2780251302d3ec3fb2cf0cae3b9d861cd8c87f9c608f5b93da28bbdfe9b2c9984e413b6d92780dc081dfdb20ae9eefa49cf61b6451
-  data.tar.gz: 50427b717de140bca88a281a4cbdfa894c7de4ce9ab562c2008686e10cc52f5ff2a4de5235022cd03c4fd295f09770a5d8904933ef103565379f19e4913c4e10
+  metadata.gz: 1da0ce79a1f218b79f81f1d299957657f6a8b7308896ecdc59dfc1e4450e55e50a03ed3d3882e2f8fc3a0664ffb0e7af7cad70fbeb75567936a9190dee559213
+  data.tar.gz: eba4dafcd0f9bc8cafde2366fdf478af5a72e0490f136389083c2bbd16474b3418e7aaed97835920cb7447193f5e15d8ca2c7b6be743b5e371be9b4938b76879

data/lib/attestify.rb

@@ -20,7 +20,12 @@ module Attestify
     @root ||= File.realpath(File.expand_path("../..", __FILE__)).freeze
   end
 
+  def self.disable_autorun
+    @autorun_disabled = true
+    @autorun.disable if @autorun
+  end
+
   def self.autorun
-    @autorun ||= Attestify::Autorun.new.tap(&:enable)
+    @autorun ||= Attestify::Autorun.new.tap { |a| a.enable unless @autorun_disabled }
   end
 end

data/lib/attestify/assertions.rb

@@ -9,100 +9,97 @@ module Attestify
     autoload :OutputAssertion, "attestify/assertions/output_assertion"
 
     def assert(value, message = nil)
-      record_assert(value) { message || "Failed assertion." }
+      record_assert(value, message) { "Failed assertion." }
     end
 
     def assert_empty(object, message = nil)
       if object.respond_to?(:empty?)
-        record_assert(object.empty?) { message || "Expected #{object.inspect} to be empty" }
+        record_assert(object.empty?, message) { "Expected #{object.inspect} to be empty" }
       else
-        record_assert(false) { message || "Expected #{object.inspect} to be empty, but it didn't respond_to(:empty?)" }
+        record_assert(false, message) { "Expected #{object.inspect} to be empty, but it didn't respond_to(:empty?)" }
       end
     end
 
     def assert_equal(expected, actual, message = nil)
-      record_assert(expected == actual) { message || "Expected #{expected.inspect} == #{actual.inspect}" }
+      record_assert(expected == actual, message) { "Expected #{expected.inspect} == #{actual.inspect}" }
     end
 
     def assert_in_delta(expected, actual, delta = 0.001, message = nil)
-      record_assert((expected - actual).abs < delta) do
-        message || "Expected #{expected.inspect} == #{actual.inspect} within #{delta.inspect}"
+      record_assert((expected - actual).abs < delta, message) do
+        "Expected #{expected.inspect} == #{actual.inspect} within #{delta.inspect}"
       end
     end
 
     def assert_includes(collection, object, message = nil)
       if collection.respond_to?(:include?)
-        record_assert(collection.include?(object)) do
-          message || "Expected #{collection.inspect} to include?(#{object.inspect})"
+        record_assert(collection.include?(object), message) do
+          "Expected #{collection.inspect} to include?(#{object.inspect})"
         end
       else
-        record_assert(false) do
-          message || "Expected #{collection.inspect} to include?(#{object.inspect}), " \
-                     "but it didn't respond_to(:include?)"
+        record_assert(false, message) do
+          "Expected #{collection.inspect} to include?(#{object.inspect}), but it didn't respond_to(:include?)"
         end
       end
     end
 
     def assert_instance_of(clazz, object, message = nil)
       if clazz.is_a?(Module)
-        record_assert(object.instance_of?(clazz)) do
-          message || "Expected #{object.inspect} to be an instance_of?(#{clazz.inspect})"
+        record_assert(object.instance_of?(clazz), message) do
+          "Expected #{object.inspect} to be an instance_of?(#{clazz.inspect})"
         end
       else
-        record_assert(false) do
-          message || "Expected #{object.inspect} to be an instance_of?(#{clazz.inspect}), " \
-                     "but #{clazz.inspect} is not a Class or Module"
+        record_assert(false, message) do
+          "Expected #{object.inspect} to be an instance_of?(#{clazz.inspect}), " \
+          "but #{clazz.inspect} is not a Class or Module"
         end
       end
     end
 
     def assert_kind_of(clazz, object, message = nil)
       if clazz.is_a?(Module)
-        record_assert(object.is_a?(clazz)) do
-          message || "Expected #{object.inspect} to be a kind_of?(#{clazz.inspect})"
+        record_assert(object.is_a?(clazz), message) do
+          "Expected #{object.inspect} to be a kind_of?(#{clazz.inspect})"
         end
       else
-        record_assert(false) do
-          message || "Expected #{object.inspect} to be a kind_of?(#{clazz.inspect}), " \
-                     "but #{clazz.inspect} is not a Class or Module"
+        record_assert(false, message) do
+          "Expected #{object.inspect} to be a kind_of?(#{clazz.inspect}), but #{clazz.inspect} is not a Class or Module"
         end
       end
     end
 
     def assert_match(matcher, object, message = nil)
-      record_assert(matcher =~ object) { message || "Expected #{matcher.inspect} =~ #{object.inspect}" }
+      record_assert(matcher =~ object, message) { "Expected #{matcher.inspect} =~ #{object.inspect}" }
     end
 
     def assert_nil(object, message = nil)
-      record_assert(object.nil?) { message || "Expected #{object.inspect} to be nil" }
+      record_assert(object.nil?, message) { "Expected #{object.inspect} to be nil" }
     end
 
     def assert_operator(left_operand, operator, right_operand, message = nil)
       if left_operand.respond_to?(operator)
-        record_assert(left_operand.send(operator, right_operand)) do
-          message || "Expected #{left_operand.inspect} #{operator} #{right_operand.inspect}"
+        record_assert(left_operand.send(operator, right_operand), message) do
+          "Expected #{left_operand.inspect} #{operator} #{right_operand.inspect}"
         end
       else
-        record_assert(false) do
-          message || "Expected #{left_operand.inspect} #{operator} #{right_operand.inspect}, " \
-                     "but #{left_operand.inspect} didn't respond_to?(#{operator})"
+        record_assert(false, message) do
+          "Expected #{left_operand.inspect} #{operator} #{right_operand.inspect}, " \
+          "but #{left_operand.inspect} didn't respond_to?(#{operator})"
         end
       end
     end
 
     def assert_output(expected_stdout = nil, expected_stderr = nil, message = nil)
       stdout, stderr = capture_io { yield }
-      assertion = Attestify::Assertions::OutputAssertion.new(expected_stdout, expected_stderr, stdout, stderr, message)
-      record_assert(assertion.assert) { assertion.message }
+      assertion = Attestify::Assertions::OutputAssertion.new(expected_stdout, expected_stderr, stdout, stderr)
+      record_assert(assertion.assert, message) { assertion.message }
     end
 
     def assert_predicate(object, predicate, message = nil)
       if object.respond_to?(predicate)
-        record_assert(object.send(predicate)) { message || "Expected #{object.inspect} to be #{predicate}" }
+        record_assert(object.send(predicate), message) { "Expected #{object.inspect} to be #{predicate}" }
       else
-        record_assert(false) do
-          message || "Expected #{object.inspect} to be #{predicate}, " \
-                     "but #{object.inspect} didn't respond_to?(#{predicate})"
+        record_assert(false, message) do
+          "Expected #{object.inspect} to be #{predicate}, but #{object.inspect} didn't respond_to?(#{predicate})"
         end
       end
     end
@@ -111,11 +108,11 @@ module Attestify
       message = exceptions.pop if exceptions.last.is_a?(String)
       exceptions = [StandardError] if exceptions.empty?
       yield
-      record_assert(false) { message || "Expected one of: #{exceptions.inspect} to be raised, but nothing was raised" }
+      record_assert(false, message) { "Expected one of: #{exceptions.inspect} to be raised, but nothing was raised" }
       return nil
     rescue => e
-      record_assert(exceptions.any? { |x| e.is_a?(x) }) do
-        message || "Expected one of: #{exceptions.inspect} to be raised, but instead got: #{e.class.name}"
+      record_assert(exceptions.any? { |x| e.is_a?(x) }, message) do
+        "Expected one of: #{exceptions.inspect} to be raised, but instead got: #{e.class.name}"
       end
 
       return e
@@ -123,31 +120,31 @@ module Attestify
 
     def assert_respond_to(object, method, message = nil)
       if method.is_a?(String) || method.is_a?(Symbol)
-        record_assert(object.respond_to?(method)) do
-          message || "Expected #{object.inspect} to respond_to?(#{method.inspect})"
+        record_assert(object.respond_to?(method), message) do
+          "Expected #{object.inspect} to respond_to?(#{method.inspect})"
         end
       else
-        record_assert(false) do
-          message || "Expected #{object.inspect} to respond_to?(#{method.inspect}), " \
-                     "but #{method.inspect} is not a String or Symbol"
+        record_assert(false, message) do
+          "Expected #{object.inspect} to respond_to?(#{method.inspect}), " \
+          "but #{method.inspect} is not a String or Symbol"
         end
       end
     end
 
     def assert_same(expected, actual, message = nil)
-      record_assert(expected.equal?(actual)) { message || "Expected #{expected.inspect} is equal?(#{actual.inspect})" }
+      record_assert(expected.equal?(actual), message) { "Expected #{expected.inspect} is equal?(#{actual.inspect})" }
     end
 
     def assert_silent(message = nil)
       stdout, stderr = capture_io { yield }
-      assertion = Attestify::Assertions::OutputAssertion.new("", "", stdout, stderr, message)
+      assertion = Attestify::Assertions::OutputAssertion.new("", "", stdout, stderr)
 
-      record_assert(assertion.assert) do
-        message || "Expected silence, but instead got: $stdout: #{stdout.inspect}, and $stderr: #{stderr.inspect}"
+      record_assert(assertion.assert, message) do
+        "Expected silence, but instead got: $stdout: #{stdout.inspect}, and $stderr: #{stderr.inspect}"
       end
     end
 
-    def assert_42(expected, message = nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/LineLength, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def assert_42(expected, message = nil) # rubocop:disable Metrics/MethodLength
       record_assert(
         if expected.is_a?(Numeric)
           expected == 42
@@ -157,9 +154,9 @@ module Attestify
           expected.send("42?")
         elsif expected.respond_to?(:forty_two?)
           expected.forty_two?
-        end
+        end, message
       ) do
-        message || "Answer to the Ultimate Question of Life, The Universe, and Everything is Incorrect"
+        "Answer to the Ultimate Question of Life, The Universe, and Everything is Incorrect"
       end
     end
 
@@ -206,7 +203,7 @@ module Attestify
     end
 
     def flunk(message = nil)
-      record_assert(false) { message || "Flunked assertion." }
+      record_assert(false, message) { "Flunked assertion." }
     end
 
     def pass(_message = nil)
@@ -214,31 +211,31 @@ module Attestify
     end
 
     def refute(value, message = nil)
-      record_assert(!value) { message || "Failed refutation." }
+      record_assert(!value, message) { "Failed refutation." }
     end
 
     def refute_empty(object, message = nil)
       if object.respond_to?(:empty?)
-        record_assert(!object.empty?) { message || "Expected #{object.inspect} to not be empty" }
+        record_assert(!object.empty?, message) { "Expected #{object.inspect} to not be empty" }
       else
         pass
       end
     end
 
     def refute_equal(expected, actual, message = nil)
-      record_assert(expected != actual) { message || "Expected #{expected.inspect} != #{actual.inspect}" }
+      record_assert(expected != actual, message) { "Expected #{expected.inspect} != #{actual.inspect}" }
     end
 
     def refute_in_delta(expected, actual, delta = 0.001, message = nil)
-      record_assert((expected - actual).abs >= delta) do
-        message || "Expected #{expected.inspect} != #{actual.inspect} within #{delta.inspect}"
+      record_assert((expected - actual).abs >= delta, message) do
+        "Expected #{expected.inspect} != #{actual.inspect} within #{delta.inspect}"
       end
     end
 
     def refute_includes(collection, object, message = nil)
       if collection.respond_to?(:include?)
-        record_assert(!collection.include?(object)) do
-          message || "Expected #{collection.inspect} to not include?(#{object.inspect})"
+        record_assert(!collection.include?(object), message) do
+          "Expected #{collection.inspect} to not include?(#{object.inspect})"
         end
       else
         pass
@@ -247,8 +244,8 @@ module Attestify
 
     def refute_instance_of(clazz, object, message = nil)
       if clazz.is_a?(Module)
-        record_assert(!object.instance_of?(clazz)) do
-          message || "Expected #{object.inspect} to not be an instance_of?(#{clazz.inspect})"
+        record_assert(!object.instance_of?(clazz), message) do
+          "Expected #{object.inspect} to not be an instance_of?(#{clazz.inspect})"
         end
       else
         pass
@@ -257,8 +254,8 @@ module Attestify
 
     def refute_kind_of(clazz, object, message = nil)
       if clazz.is_a?(Module)
-        record_assert(!object.is_a?(clazz)) do
-          message || "Expected #{object.inspect} to not be a kind_of?(#{clazz.inspect})"
+        record_assert(!object.is_a?(clazz), message) do
+          "Expected #{object.inspect} to not be a kind_of?(#{clazz.inspect})"
         end
       else
         pass
@@ -266,17 +263,17 @@ module Attestify
     end
 
     def refute_match(matcher, object, message = nil)
-      record_assert(!(matcher =~ object)) { message || "Expected not #{matcher.inspect} =~ #{object.inspect}" }
+      record_assert(!(matcher =~ object), message) { "Expected not #{matcher.inspect} =~ #{object.inspect}" }
     end
 
     def refute_nil(object, message = nil)
-      record_assert(!object.nil?) { message || "Expected #{object.inspect} to not be nil" }
+      record_assert(!object.nil?, message) { "Expected #{object.inspect} to not be nil" }
     end
 
     def refute_operator(left_operand, operator, right_operand, message = nil)
       if left_operand.respond_to?(operator)
-        record_assert(!left_operand.send(operator, right_operand)) do
-          message || "Expected not #{left_operand.inspect} #{operator} #{right_operand.inspect}"
+        record_assert(!left_operand.send(operator, right_operand), message) do
+          "Expected not #{left_operand.inspect} #{operator} #{right_operand.inspect}"
         end
       else
         pass
@@ -285,7 +282,7 @@ module Attestify
 
     def refute_predicate(object, predicate, message = nil)
       if object.respond_to?(predicate)
-        record_assert(!object.send(predicate)) { message || "Expected not #{object.inspect} #{predicate}" }
+        record_assert(!object.send(predicate), message) { "Expected not #{object.inspect} #{predicate}" }
       else
         pass
       end
@@ -293,8 +290,8 @@ module Attestify
 
     def refute_respond_to(object, method, message = nil)
       if method.is_a?(String) || method.is_a?(Symbol)
-        record_assert(!object.respond_to?(method)) do
-          message || "Expected #{object.inspect} to not respond_to?(#{method.inspect})"
+        record_assert(!object.respond_to?(method), message) do
+          "Expected #{object.inspect} to not respond_to?(#{method.inspect})"
         end
       else
         pass
@@ -302,8 +299,8 @@ module Attestify
     end
 
     def refute_same(expected, actual, message = nil)
-      record_assert(!expected.equal?(actual)) do
-        message || "Expected #{expected.inspect} is not equal?(#{actual.inspect})"
+      record_assert(!expected.equal?(actual), message) do
+        "Expected #{expected.inspect} is not equal?(#{actual.inspect})"
       end
     end
 
@@ -323,11 +320,19 @@ module Attestify
 
     private
 
-    def record_assert(passed)
+    def record_assert(passed, message = nil)
       if passed
         assertions.record(passed)
       else
-        assertions.record(passed, yield, caller_locations(2))
+        assertions.record(passed, combine_message(message, yield), caller_locations(2))
+      end
+    end
+
+    def combine_message(message, default_message)
+      if message && !message.empty?
+        "#{message}\n#{default_message}"
+      else
+        default_message
       end
     end
   end

data/lib/attestify/assertions/output_assertion.rb

@@ -2,12 +2,11 @@ module Attestify
   module Assertions
     # A helper class for Attestify::Assertions#assert_output.
     class OutputAssertion
-      def initialize(expected_stdout, expected_stderr, stdout, stderr, message)
+      def initialize(expected_stdout, expected_stderr, stdout, stderr)
         @expected_stdout = expected_stdout
         @expected_stderr = expected_stderr
         @stdout = stdout
         @stderr = stderr
-        @message = message
       end
 
       def assert
@@ -15,7 +14,6 @@ module Attestify
       end
 
       def message
-        return @message if @message
         messages = [stdout_message, stderr_message]
         "Expected #{messages.compact.join(", and ")}"
       end

data/lib/attestify/autorun.rb

@@ -23,14 +23,22 @@ module Attestify
         end
     end
 
+    def disable
+      @disabled = true
+    end
+
     def enable
       parse_options
       require_helper
-      at_exit { start }
+      at_exit { at_exit_hook }
     end
 
     private
 
+    def at_exit_hook
+      start unless @disabled
+    end
+
     def parse_options
       option_parser.parse!(@args)
     end

data/lib/attestify/cli.rb

@@ -11,6 +11,7 @@ module Attestify
     end
 
     def self.start
+      Attestify.disable_autorun
       new.start
     end
 

data/lib/attestify/version.rb

@@ -1,3 +1,3 @@
 module Attestify
-  VERSION = "0.1.0.pre.2".freeze
+  VERSION = "0.1.0.pre.3".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attestify
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.2
+  version: 0.1.0.pre.3
 platform: ruby
 authors:
 - Mike Virata-Stone
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-15 00:00:00.000000000 Z
+date: 2016-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler