lookout 2.3.0 → 3.0.0

data/lib/lookout-3.0/diff/operations/replace.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+# Slice of the old sequence that should be replaced with one from the new
+# sequence.
+class Lookout::Diff::Operations::Replace < Lookout::Diff::Operation
+end

data/lib/lookout-3.0/diff/slice.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+# Slice (subsequence) of a sequence being “diffed”.
+class Lookout::Diff::Slice
+  # Initializes a slice of ITEMS encompassing RANGE.
+  # @param [Enumerable] items
+  # @param [Range] range
+  Value(:items, :range)
+  def initialize(items, range = 0...items.size)
+    super items, range.exclude_end? ? range.begin..range.end - 1 : range
+  end
+  include Enumerable, Comparable
+
+  # @return True if {#size} < 1
+  def empty?; size < 1 end
+
+  # @return The number of encompassed elements
+  def size; self.end - self.begin + 1 end
+
+  # @return True if {#end} + 1 = OTHER{#begin}
+  def touch?(other) self.end + 1 == other.begin end
+
+  # @return True if {#begin} < OTHER{#begin}
+  def begin_before?(other) self.begin < other.begin end
+
+  # @return True if {#end} > OTHER{#end}
+  def end_after?(other) self.end > other.end end
+
+  # @return [Slice] A new slice beginning at OTHER{#end} + 1
+  def begin_after(other) begin_at(other.end + 1) end
+
+  # @return [Slice] A new slice ending at OTHER{#begin} - 1
+  def end_before(other) end_at(other.begin - 1) end
+
+  # @return [Slice] A new slice encompassing RANGE
+  def at(range) self.class.new(items, range) end
+
+  # @return A new slice encompassing the receiver and OTHER
+  # @note Logically, the receiver should {#touch?} OTHER, but this isn’t
+  #   enforced.
+  def +(other) at(self.begin..other.end) end
+
+  # @return [Slice] A new slice beginning at INDEX
+  def begin_at(index) at(index..self.end) end
+
+  # @return [Slice] A new slice ending at INDEX
+  def end_at(index) at(self.begin..index) end
+
+  # @overload
+  #   Enumerates the encompassed elements.
+  #
+  #   @yieldparam element
+  # @overload
+  #   @return [Enumerator<Object>] An Enumerator over the encompassed elements
+  def each
+    return enum_for(__method__) unless block_given?
+    range.each do |index| yield items[index] end
+    self
+  end
+
+  # @overload
+  #   Enumerates the encompassed elements and their indexes.
+  #
+  #   @yieldparam element
+  #   @yieldparam [Integer] index
+  # @overload
+  #   @return [Enumerator<Object, Integer>] An Enumerator over the encompassed
+  #     elements and their indexes
+  def each_with_index
+    return enum_for(__method__) unless block_given?
+    range.each do |index| yield items[index], index end
+    self
+  end
+
+  # @return [Enumerable<Object>] The encompassed elements
+  def to_items; items[range] end
+
+  # @return The INDEXth element
+  def [](index) items[index] end
+
+  # @return [Integer] The index of the first element
+  def begin; range.begin end
+
+  # @return [Integer] The index of the last element
+  def end; range.end end
+
+  # @return The comparison of the receiver’s {#begin} and {#end}
+  #   against those of OTHER
+  def <=>(other)
+    return nil unless self.class == other.class and items == other.items
+    (self.begin <=> other.begin).nonzero? or
+      (self.end <=> other.end).nonzero? or
+      0
+  end
+
+  alias eql? ==
+end

data/lib/lookout-3.0/difference.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+# Function-like namespace for type-specific difference reports.  Used by
+# {Expected} and {Expect} to generate difference reports between their expected
+# values and actual results.
+#
+# {Object} is the base class for all classes defined under this namespace, so
+# look to it for guidance.
+module Lookout::Difference
+end

data/lib/lookout-3.0/difference/array.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Array}s.
+class Lookout::Difference::Array < Lookout::Difference::Object
+  # @return [Diff::Formats::Unified, super] A unified “diff” between {#actual}
+  #   and {#expected} unless {#expected} contains one element or {#actual}
+  #   isn’t an Array, {super} otherwise
+  def diff
+    return super if expected.size == 1 or not Array === actual
+    Lookout::Diff::Formats::Unified.
+      new(Lookout::Diff::Groups.
+            new(Lookout::Diff::Operations.
+                  new(Lookout::Diff::Algorithms::Difflib.
+                        new(actual, expected))))
+  end
+
+  private
+
+  # @return [::String, super] The symbol ‘≉’ if {#actual} is an Array of the
+  #   same #size as {#expected}, {super} otherwise
+  def symbol; Array === actual && expected.size == actual.size ? '≉' : super end
+end

data/lib/lookout-3.0/difference/exception.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Exception}s.  The report differs from that of
+# {Object} in that it tries to “diff” the exception messages and that it uses
+# ‘≉’ instead of ‘≠’ to show that the actual result doesn’t match an expected
+# Regexp.
+class Lookout::Difference::Exception < Lookout::Difference::Object
+  # Initializes a difference report between the ACTUAL result and the EXPECTED
+  # value, where REGEXP is the {::Regexp} found inside EXPECTED, if any.
+  # @param [::Exception] actual
+  # @param [::Exception] expected
+  # @param [::Regexp, nil] regexp
+  def initialize(actual, expected, regexp = nil)
+    @regexp = regexp
+    super actual, expected
+  end
+
+  # @return [Enumerable<String>, super] The result of {String#diff} between
+  #   {#expected}’s message and {#actual}’s message if {#actual} and
+  #   {#expected} are of the same class and {#expected} and {#actual}’s
+  #   messages are Strings, {super} otherwise
+  def diff
+    return super unless expected.class == actual.class and
+      String === expected.message and
+      not @regexp and
+      (m = actual.message rescue nil) and
+      String === m
+    expected.message.to_lookout_expected.difference(m).diff
+  end
+
+  private
+
+  # @return [::String, super] A specially crafted inspection String containing
+  #   the Regexp if {#expected} contains a Regexp, {super} otherwise
+  def inspect_expected; @regexp ? '#<%s: %p>' % [expected.class, @regexp] : super end
+
+  # @return [::String, super] The symbol ‘≉’ if a Regexp was found inside
+  #   {#expected}, {super} otherwise
+  def symbol; @regexp ? '≉' : super end
+end

data/lib/lookout-3.0/difference/hash.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Hash}es.  These reports are generated by
+# turning the Hashes into {::Array}s, sorting them by key, and finally mapping
+# the keys and values to their String inspections.
+class Lookout::Difference::Hash < Lookout::Difference::Object
+  # @return [Lookout::Diff::Formats::Set, super] A set “diff” unless
+  #   {#expected} contains one element or {#actual} isn’t a Hash, {super}
+  #   otherwise
+  def diff
+    return super if expected.size == 1 or not Hash === actual
+    Lookout::Diff::Formats::Set.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new(array(actual), array(expected))))
+  end
+
+  private
+
+  # @return [::String, super] The symbol ‘≉’ if {#actual} is a Hash of the
+  #   same #size as {#expected}, {super} otherwise
+  def symbol; Hash === actual && expected.size == actual.size ? '≉' : super end
+
+  def array(hash)
+    hash.to_a.sort_by{ |key, _| key }.map{ |key, value|
+      [Lookout::Inspect.new(key, 'key'),
+       ' => ',
+       Lookout::Inspect.new(value, 'value')].join('')
+    }
+  end
+end

data/lib/lookout-3.0/difference/lookout.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+# Namespace for difference report generators for under the {Lookout} namespace.
+module Lookout::Difference::Lookout
+end

data/lib/lookout-3.0/difference/lookout/actual.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+# Namespace for difference report generators for objects under the
+# {Lookout::Actual} namespace.
+module Lookout::Difference::Lookout::Actual
+end

data/lib/lookout-3.0/difference/lookout/actual/method.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Lookout::Actual::Method}s.
+class Lookout::Difference::Lookout::Actual::Method < Lookout::Difference::Object
+  # @return [::String] A String of the form ¬{#actual}#{#expected}, where
+  #   {#actual} is the object that the query method {#expected} was invoked upon
+  def message; [symbol, inspect_actual, inspect_expected].join('') end
+
+  private
+
+  # @return [::String] The inequality symbol ‘¬’
+  def symbol; '¬' end
+end

data/lib/lookout-3.0/difference/lookout/actual/not.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+# Namespace for difference report generators for objects under the
+# {::Lookout::Actual::Not} namespace.
+module Lookout::Difference::Lookout::Actual::Not
+end

data/lib/lookout-3.0/difference/lookout/actual/not/method.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Lookout::Actual::Not::Method}s.
+class Lookout::Difference::Lookout::Actual::Not::Method < Lookout::Difference::Lookout::Actual::Method
+  private
+
+  # @return [::String] The inequality symbol ‘’
+  def symbol; '' end
+end

data/lib/lookout-3.0/difference/lookout/output.rb

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Lookout::Output}s.
+class Lookout::Difference::Lookout::Output < Lookout::Difference::Object
+  # @return [Enumerable<::String>] The result of
+  #   {#expected}{::Lookout::Output#diff #diff}({#actual})
+  def diff; expected.diff(actual) end
+end

data/lib/lookout-3.0/difference/lookout/reception.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Lookout::Reception}s.  Differences are seen
+# when the number of times a method call is received isn’t within the range of
+# expected number of receptions.
+class Lookout::Difference::Lookout::Reception < Lookout::Difference::Range
+  # Initializes a difference report between the ACTUAL number of receptions
+  # against the range of EXPECTED number of receptions.
+  # @param [Integer] actual
+  # @param [Range] expected
+  def initialize(actual, expected)
+    super actual, expected.range
+    @reception = expected
+  end
+
+  # @return [Enumerable<::String>] An Enumerable containing the difference
+  #   report message generated from the method mock
+  def diff
+    [Lookout::Reception::Error.from(@reception, actual, expected).message]
+  end
+end

data/lib/lookout-3.0/difference/lookout/warning.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Lookout::Warning}s.
+class Lookout::Difference::Lookout::Warning < Lookout::Difference::Lookout::Output
+  private
+
+  # @return [::String] The inequality symbol ‘≉’
+  def symbol; '≉' end
+end

data/lib/lookout-3.0/difference/module.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Module}s.  The report differs from that of
+# {Object} in that it uses ‘≉’ instead of ‘≠’ to show that the actual result
+# isn’t an instance of (doesn’t case match) the expected Module.
+class Lookout::Difference::Module < Lookout::Difference::Object
+  private
+
+  # @return [::String, super] The symbol ‘≉’ unless {#actual} is a Module,
+  #   {super} otherwise
+  def symbol; Module === actual ? super : '≉' end
+end

data/lib/lookout-3.0/difference/object.rb

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Object}s.  This is the base difference report
+# class and should be subclassed if something more specific fits the bill.  The
+# actual result and expected value are assumed to differ and you’ll surely get
+# confused if they don’t.  Determining if the objects differ is up to the
+# caller.
+class Lookout::Difference::Object
+  # Initializes a difference report between the ACTUAL result and the EXPECTED
+  # value.
+  # @param [::Object] actual
+  # @param [::Object] expected
+  def initialize(actual, expected) @actual, @expected = actual, expected end
+
+  # @return [::String] The concatenation of {#inspect_actual}, {#symbol}, and
+  #   {#inspect_expected}, explaining how {#actual} differs from {#expected}
+  # @note Subclasses may override this method to provide more specific
+  #   messages for their specific types.
+  def message; [inspect_actual, symbol, inspect_expected].join('') end
+
+  # @return [Enumerable<String>] An Enumerable over the formatted operations
+  #   that would have to be applied to {#actual} to get {#expected}
+  # @note The Enumerable returned by this specific implementation is empty.
+  #   Subclasses may provide more detailed information for their specific
+  #   types.
+  def diff; [] end
+
+  # @return [::String] The concatenation of {#message} and {#diff}
+  # @note This method should not be overridden by subclasses, as it goes to
+  #   some lengths to safely return a String for display.
+  def to_s
+    begin
+      m = message
+    rescue => e
+      raise if self.class == Lookout::Difference::Object rescue true
+      return '%s (cannot generate more specific failure message: %s)' %
+        [Lookout::Difference::Object.new(actual, expected).message, e]
+    end
+    begin
+      d = diff.to_a.join("\n")
+    rescue => e
+      d = '(cannot diff expected value and actual result: %s)' % e
+    end
+    d.empty? ? m : [m, d].join(d.include?("\n") ? "\n" : ': ')
+  end
+
+  # @return True if the receiver’s class, {#message}, and {#diff} equal those
+  #   of OTHER
+  def ==(other)
+    self.class == other.class and
+      message == other.message and diff.to_s == other.diff.to_s
+  end
+
+  # @return a hash value based on {#message} and {#diff}
+  def hash; @hash ||= [message, diff.to_s].hash end
+
+  # @return [::Object] The actual result
+  attr_reader :actual
+
+  # @return [::Object] The expected value
+  attr_reader :expected
+
+  private
+
+  # @return [::String] The safely inspected value of {#actual}, see {Inspect}
+  def inspect_actual; Lookout::Inspect.new(actual, 'actual result').call end
+
+  # @return [::String] The safely inspected value of {#expected}, see {Inspect}
+  def inspect_expected; Lookout::Inspect.new(expected, 'expected value').call end
+
+  # @return [::String] The inequality symbol to use (‘≠’)
+  def symbol; '≠' end
+end

data/lib/lookout-3.0/difference/range.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Range}s.  The report differs from
+# that of {Object} in that it uses ‘∉’ instead of ‘≠’ to show that the actual
+# result isn’t a member of the expected Range.
+class Lookout::Difference::Range < Lookout::Difference::Object
+  private
+
+  # @return [::String, super] The symbol ‘∉’ unless {#actual} is a Range,
+  #   {super} otherwise
+  def symbol; Range === actual ? super : '∉' end
+end

data/lib/lookout-3.0/difference/regexp.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Regexp}s.  The report differs from that of
+# {Object} in that it uses ‘≉’ instead of ‘≠’ to show that the actual result
+# doesn’t match the expected Regexp.
+class Lookout::Difference::Regexp < Lookout::Difference::Object
+  private
+
+  # @return [::String, super] The symbol ‘≉’ unless {#actual} is a Regexp,
+  #   {super} otherwise
+  def symbol; Regexp === actual ? super : '≉' end
+end

data/lib/lookout-3.0/difference/string.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::String}s.
+class Lookout::Difference::String < Lookout::Difference::Object
+  # @return [Diff::Formats::Unified, Diff::Formats::Inline, super] A unified
+  #   “diff” if {#actual} or {#expected} include a newline, an inline “diff”
+  #   otherwise, or {super} if {#actual} isn’t a String
+  def diff
+    return super unless String === actual
+    (actual.include? "\n" or expected.include? "\n") ?
+      Lookout::Diff::Formats::Unified.
+        new(Lookout::Diff::Groups.
+              new(Lookout::Diff::Operations.
+                    new(Lookout::Diff::Algorithms::Difflib.
+                          new(actual.split("\n"), expected.split("\n"))))) :
+      Lookout::Diff::Formats::Inline.
+        new(Lookout::Diff::Operations.
+              new(Lookout::Diff::Algorithms::Difflib.
+                    new(actual, expected)))
+  end
+end

data/lib/lookout-3.0/difference/symbol.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+# Difference reports between {::Symbol}s.
+class Lookout::Difference::Symbol < Lookout::Difference::Object
+  # Initializes a difference report between the ACTUAL result Symbol and the
+  # EXPECTED value Symbol, with QUERY being the name of the query method
+  # that EXPECTED represents, if any, whose result may be NEGATED.
+  # @param (see Object#initialize)
+  # @param [::String, nil] query
+  # @param [Boolean] negated
+  def initialize(actual, expected, query, negated)
+    super actual, expected
+    @query, @negated = query, negated
+  end
+
+  # @return [::String, super] A String of the form {#actual}#QUERY, prefixed
+  #   by ‘¬’ if the query was negated, if there was a query, {super} otherwise
+  def message
+    @query ? [@negated ? '' : '¬', inspect_actual, '#', @query].join('') : super
+  end
+end