given_core 3.0.0.beta.1

data/lib/given/failure.rb

@@ -0,0 +1,56 @@
+
+module Given
+
+  # Failure objects will raise the given exception whenever you try
+  # to send it *any* message.
+  class Failure < BasicObject
+    undef_method :==, :!=, :!
+
+    def initialize(exception)
+      @exception = exception
+    end
+
+    def is_a?(klass)
+      klass == Failure
+    end
+
+    def ==(other)
+      if failure_matcher?(other)
+        other.matches?(self)
+      else
+        die
+      end
+    end
+
+    def !=(other)
+      if failure_matcher?(other)
+        other.does_not_match?(self)
+      else
+        die
+      end
+    end
+
+    def method_missing(sym, *args, &block)
+      die
+    end
+
+    def respond_to?(method_symbol)
+      method_symbol == :call ||
+        method_symbol == :== ||
+        method_symbol == :!= ||
+        method_symbol == :is_a?
+    end
+
+    private
+
+    def die
+      ::Kernel.raise @exception
+    end
+
+    def failure_matcher?(other)
+      other.is_a?(::Given::FailureMatcher) ||
+        other.is_a?(::RSpec::Given::HaveFailed::HaveFailedMatcher)
+    end
+
+  end
+end

data/lib/given/failure_matcher.rb

@@ -0,0 +1,63 @@
+module Given
+
+  class FailureMatcher
+    def initialize(exception_class, message_pattern)
+      @no_pattern = false
+      @expected_exception_class = exception_class
+      @expected_message_pattern = message_pattern
+      if @expected_message_pattern.nil?
+        @expected_message_pattern = //
+        @no_pattern = true
+      elsif @expected_message_pattern.is_a?(String)
+        @expected_message_pattern =
+          Regexp.new("\\A" + Regexp.quote(@expected_message_pattern) + "\\Z")
+      end
+    end
+
+    def matches?(possible_failure)
+      if possible_failure.respond_to?(:call)
+        make_sure_it_throws_an_exception(possible_failure)
+      else
+        Given.fail_with("#{description}, but nothing failed")
+      end
+    end
+
+    def does_not_match?(possible_failure)
+      if possible_failure.respond_to?(:call)
+        false
+      else
+        true
+      end
+    end
+
+    private
+
+    def make_sure_it_throws_an_exception(possible_failure)
+      possible_failure.call
+      Given.fail_with("Expected an exception")
+    rescue Exception => ex
+      if ! ex.is_a?(@expected_exception_class)
+        Given.fail_with("#{description}, but got #{ex.inspect}")
+      elsif @expected_message_pattern !~ ex.message
+        Given.fail_with("#{description}, but got #{ex.inspect}")
+      else
+        true
+      end
+    end
+
+    private
+
+    def description
+      result = "Expected failure with #{@expected_exception_class}"
+      result << " matching #{@expected_message_pattern.inspect}" unless @no_pattern
+      result
+    end
+  end
+
+  module FailureMethod
+    def Failure(exception_class=Exception, message_pattern=nil)
+      FailureMatcher.new(exception_class, message_pattern)
+    end
+  end
+
+end

data/lib/given/file_cache.rb

@@ -0,0 +1,18 @@
+
+module Given
+  class FileCache
+    def initialize
+      @lines = {}
+    end
+
+    def get(file_name)
+      @lines[file_name] ||= read_lines(file_name)
+    end
+
+    private
+
+    def read_lines(file_name)
+      open(file_name) { |f| f.readlines }
+    end
+  end
+end

data/lib/given/fuzzy_number.rb

@@ -0,0 +1,68 @@
+
+module Given
+  module Fuzzy
+    class FuzzyNumber
+
+      DEFAULT_EPSILON = 10 * Float::EPSILON
+
+      attr_reader :exact_value, :delta_amount
+
+      def initialize(exact_value)
+        @exact_value = exact_value
+        @delta_amount = exact_value * DEFAULT_EPSILON
+      end
+
+      def exactly_equals?(other)
+        other.is_a?(self.class) &&
+          exact_value == other.exact_value &&
+          delta_amount == other.delta_amount
+      end
+
+      # Low limit of the fuzzy number.
+      def low_limit
+        exact_value - delta_amount
+      end
+
+      # High limit of the fuzzy number.
+      def high_limit
+        exact_value + delta_amount
+      end
+
+      # True if the other number is in range of the fuzzy number.
+      def ==(other)
+        (other - exact_value).abs <= delta_amount
+      end
+
+      def to_s
+        "<Approximately #{exact_value} +/- #{delta_amount}>"
+      end
+
+      # Set the delta for a fuzzy number.
+      def delta(delta)
+        @delta_amount = delta.abs
+        self
+      end
+
+      # Specifying a percentage of the exact number to be used in
+      # setting the delta.
+      def percent(percentage)
+        delta(exact_value * (percentage / 100.0))
+      end
+
+      # Specifying the number of epsilons to be used in setting the
+      # delta.
+      def epsilon(neps)
+        delta(exact_value * (neps * Float::EPSILON))
+      end
+    end
+
+    # Create an approximate number that is approximately equal to
+    # the given number, plus or minus the delta value. If no
+    # explicit delta is given, then the default delta that is about
+    # 10X the size of the smallest possible change in the given
+    # number will be used.
+    def about(*args)
+      FuzzyNumber.new(*args)
+    end
+  end
+end

data/lib/given/fuzzy_shortcuts.rb

@@ -0,0 +1 @@
+require 'given/ext/numeric'

data/lib/given/line_extractor.rb

@@ -0,0 +1,41 @@
+require 'given/file_cache'
+
+module Given
+  class LineExtractor
+    def initialize(file_cache=nil)
+      @files = file_cache || FileCache.new
+    end
+
+    def line(file_name, line)
+      lines = @files.get(file_name)
+      extract_lines_from(lines, line-1)
+    end
+
+    def to_s
+      "<LineExtractor>"
+    end
+
+    private
+
+    def extract_lines_from(lines, line_index)
+      result = lines[line_index]
+      if continued?(result)
+        level = indentation_level(result)
+        begin
+          line_index += 1
+          result << lines[line_index]
+        end while indentation_level(lines[line_index]) > level
+      end
+      result
+    end
+
+    def continued?(string)
+      string =~ /(\{|do) *$/
+    end
+
+    def indentation_level(string)
+      string =~ /^(\s*)\S/
+      $1.nil? ? 1000000 : $1.size
+    end
+  end
+end

data/lib/given/module_methods.rb

@@ -0,0 +1,69 @@
+
+module Given
+  # Does this platform support natural assertions?
+  RBX_IN_USE = (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx')
+  JRUBY_IN_USE = defined?(JRUBY_VERSION)
+
+  NATURAL_ASSERTIONS_SUPPORTED = ! (JRUBY_IN_USE || RBX_IN_USE)
+
+  def self.framework
+    @_gvn_framework
+  end
+
+  def self.framework=(framework)
+    @_gvn_framework = framework
+  end
+
+  def self.source_caching_disabled
+    @_gvn_source_caching_disabled
+  end
+
+  def self.source_caching_disabled=(value)
+    @_gvn_source_caching_disabled = value
+  end
+
+  # Detect the formatting requested in the given configuration object.
+  #
+  # If the format requires it, source caching will be enabled.
+  def self.detect_formatters(c)
+    format_active = c.formatters.any? { |f| f.class.name !~ /ProgressFormatter/ }
+    Given.source_caching_disabled = ! format_active
+  end
+
+  # Globally enable/disable natural assertions.
+  #
+  # There is a similar function in Extensions that works at a
+  # describe or context scope.
+  def self.use_natural_assertions(enabled=true)
+    ok_to_use_natural_assertions(enabled)
+    @natural_assertions_enabled = enabled
+  end
+
+  # TRUE if natural assertions are globally enabled?
+  def self.natural_assertions_enabled?
+    @natural_assertions_enabled
+  end
+
+  # Is is OK to use natural assertions on this platform.
+  #
+  # An error is raised if the the platform does not support natural
+  # assertions and the flag is attempting to enable them.
+  def self.ok_to_use_natural_assertions(enabled)
+    if enabled && ! NATURAL_ASSERTIONS_SUPPORTED
+      fail ArgumentError, "Natural Assertions are disabled for JRuby"
+    end
+  end
+
+  # Fail an example with the given messages.
+  #
+  # This should be the only place we reference the RSpec function.
+  # Everywhere else in rspec-given should be calling this function.
+  def self.fail_with(*args)
+    Given.framework.fail_with(*args)
+  end
+
+  # Error object used by RSpec to indicate a pending example.
+  def self.pending_error
+    Given.framework.pending_error
+  end
+end

data/lib/given/natural_assertion.rb

@@ -0,0 +1,177 @@
+require 'given/module_methods'
+require 'given/evaluator'
+
+if Given::NATURAL_ASSERTIONS_SUPPORTED
+  require 'ripper'
+  require 'sorcerer'
+end
+
+module Given
+
+  InvalidThenError = Class.new(StandardError)
+
+  class NaturalAssertion
+
+    def initialize(clause_type, block, example, line_extractor)
+      @clause_type = clause_type
+      @evaluator = Evaluator.new(example, block)
+      @line_extractor = line_extractor
+      set_file_and_line(block)
+    end
+
+    VOID_SEXP = [:void_stmt]
+
+    def has_content?
+      assertion_sexp != VOID_SEXP
+    end
+
+    def message
+      @output = "#{@clause_type} expression failed at #{source_line}\n"
+      @output << "Failing expression: #{source.strip}\n" if @clause_type != "Then"
+      explain_failure
+      display_pairs(expression_value_pairs)
+      @output << "\n"
+      @output
+    end
+
+    private
+
+    BINARY_EXPLAINATIONS = {
+      :== => "to equal",
+      :!= => "to not equal",
+      :<  => "to be less than",
+      :<= => "to be less or equal to",
+      :>  => "to be greater than",
+      :>= => "to be greater or equal to",
+      :=~ => "to match",
+      :!~ => "to not match",
+    }
+
+    def explain_failure
+      if assertion_sexp.first == :binary && msg = BINARY_EXPLAINATIONS[assertion_sexp[2]]
+        @output << explain_expected("expected", assertion_sexp[1], msg, assertion_sexp[3])
+      end
+    end
+
+    def explain_expected(expect_msg, expect_sexp, got_msg, got_sexp)
+      width = [expect_msg.size, got_msg.size].max
+      sprintf("%#{width}s: %s\n%#{width}s: %s\n",
+        expect_msg, eval_sexp(expect_sexp),
+        got_msg, eval_sexp(got_sexp))
+    end
+
+    def expression_value_pairs
+      assertion_subexpressions.map { |exp|
+        [exp, @evaluator.eval_string(exp)]
+      }
+    end
+
+    def assertion_subexpressions
+      Sorcerer.subexpressions(assertion_sexp).reverse.uniq.reverse
+    end
+
+    def assertion_sexp
+      @assertion_sexp ||= extract_test_expression(Ripper::SexpBuilder.new(source).parse)
+    end
+
+    def source
+      @source ||= @line_extractor.line(@code_file, @code_line)
+    end
+
+    def set_file_and_line(block)
+      @code_file, @code_line = eval "[__FILE__, __LINE__]", block.binding
+      @code_line = @code_line.to_i
+    end
+
+    def extract_test_expression(sexp)
+      brace_block = extract_brace_block(sexp)
+      extract_first_statement(brace_block)
+    end
+
+    def extract_brace_block(sexp)
+      unless then_block?(sexp)
+        source = Sorcerer.source(sexp)
+        fail InvalidThenError, "Unexpected code at #{source_line}\n#{source}"
+      end
+      sexp[1][2][2]
+    end
+
+    def then_block?(sexp)
+      delve(sexp,0) == :program &&
+        delve(sexp,1,0) == :stmts_add &&
+        delve(sexp,1,2,0) == :method_add_block &&
+        (delve(sexp,1,2,2,0) == :brace_block || delve(sexp,1,2,2,0) == :do_block)
+    end
+
+    def extract_first_statement(block_sexp)
+      if contains_multiple_statements?(block_sexp)
+        source = Sorcerer.source(block_sexp)
+        fail InvalidThenError, "Multiple statements in Then block at #{source_line}\n#{source}"
+      end
+      extract_statement_from_block(block_sexp)
+    end
+
+    def contains_multiple_statements?(block_sexp)
+      !(delve(block_sexp,2,0) == :stmts_add &&
+        delve(block_sexp,2,1,0) == :stmts_new)
+    end
+
+    def extract_statement_from_block(block_sexp)
+      delve(block_sexp,2,2)
+    end
+
+    # Safely dive into an array with a list of indicies. Return nil
+    # if the element doesn't exist, or if the intermediate result is
+    # not indexable.
+    def delve(ary, *indicies)
+      result = ary
+      while !indicies.empty? && result
+        return nil unless result.respond_to?(:[])
+        i = indicies.shift
+        result = result[i]
+      end
+      result
+    end
+
+    def eval_sexp(sexp)
+      expr_string = Sorcerer.source(sexp)
+      @evaluator.eval_string(expr_string)
+    end
+
+    WRAP_WIDTH = 20
+
+    def display_pairs(pairs)
+      width = suggest_width(pairs) + 4
+      pairs.each do |x, v|
+        v = adjust_indentation(v)
+        fmt = multi_line?(v) ?
+        "%-#{width}s\n#{' '*width} <- %s\n" :
+          "%-#{width}s <- %s\n"
+        @output << sprintf(fmt, v, x)
+      end
+    end
+
+    def adjust_indentation(string)
+      string.to_s.gsub(/^/, '  ')
+    end
+
+    def multi_line?(string)
+      (string.size > WRAP_WIDTH) || (string =~ /\n/)
+    end
+
+    def suggest_width(pairs)
+      pairs.map { |x,v|
+        max_line_length(v)
+      }.select { |n| n < WRAP_WIDTH }.max || 10
+    end
+
+    def max_line_length(string)
+      string.to_s.split(/\n/).map { |s| s.size }.max
+    end
+
+    def source_line
+      "#{@code_file}:#{@code_line}"
+    end
+  end
+
+end