assert_value 1.0

data/.gitignore

@@ -0,0 +1,6 @@
+*~
+*.gem
+pkg
+.kdev4
+Gemfile.lock
+.bundle

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rspec'
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010-2011 Pluron, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,100 @@
+# assert_value
+
+Checks that two values are same and "magically" replaces expected value
+with the actual in case the new behavior (and new actual value) is correct.
+Support two kind of arguments: string and code block.
+
+## String Example:
+
+It is better to start with no expected value
+
+    assert_value "foo"
+
+Then run tests as usual with "rake test". As a result you will see
+diff between expected and actual values:
+
+    Failure:
+    @@ -1,0, +1,1 @@
+    +foo
+    Accept the new value: yes to all, no to all, yes, no? [Y/N/y/n] (y):
+
+If you accept the new value your test will be automatically modified to
+
+    assert_value "foo", <<-END
+        foo
+    END
+
+## Block Example:
+
+assert_value supports code block as argument. If executed block raises exception then
+exception message is returned as actual value:
+
+    assert_value do
+        nil+1
+    end
+
+Run tests
+
+    Failure:
+    @@ -1,0, +1,1 @@
+    +Exception NoMethodError: undefined method `+' for nil:NilClass
+    Accept the new value: yes to all, no to all, yes, no? [Y/N/y/n] (y): 
+
+After the new value is accepted you get
+
+    assert_value(<<-END) do
+        Exception NoMethodError: undefined method `+' for nil:NilClass
+    END
+        nil + 1
+    end
+
+## Options:
+
+    --no-interactive skips all questions and just reports failures
+    --autoaccept prints diffs and automatically accepts all new actual values
+    --no-canonicalize turns off expected and actual value canonicalization (see below for details)
+
+Additional options can be passed during both single test file run and rake test run:
+
+In Ruby 1.8:
+
+    ruby test/unit/foo_test.rb -- --autoaccept
+    rake test TESTOPTS="-- --autoaccept"
+
+In Ruby 1.9:
+
+    ruby test/unit/foo_test.rb --autoaccept
+    rake test TESTOPTS="--autoaccept"
+
+## Canonicalization:
+
+Before comparing expected and actual strings, assert_value canonicalizes both using these rules:
+
+- indentation is ignored (except for indentation  relative to the first line of the expected/actual string)
+- ruby-style comments after "#" are ignored
+- empty lines are ignored
+- trailing whitespaces are ignored
+
+You can turn canonicalization off with --no-canonicalize option. This is useful
+when you need to regenerate expected test strings.
+To regenerate the whole test suite, run:
+
+In Ruby 1.8:
+
+    rake test TESTOPTS="-- --no-canonicalize --autoaccept"
+
+In Ruby 1.9:
+
+    rake test TESTOPTS="--no-canonicalize --autoaccept"
+
+
+## Changelog
+
+- 1.0: Rename to assert_value
+- 0.7: Support Ruby 1.9's MiniTest
+- 0.6: Support test execution on Mac
+- 0.5: Support code blocks to assert_same
+- 0.4: Added support for code blocks as argument
+- 0.3: Ruby 1.9 is supported
+- 0.2: Make assert_same useful as a standalone gem. Bugfixes
+- 0.1: Initial release

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test assert_value.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc "Run the specs."
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "test/**/*_spec.rb"
+end
+
+desc 'Generate documentation for assert_value.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'assert_value'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/assert_value.gemspec

@@ -0,0 +1,19 @@
+require 'rubygems'
+
+SPEC = Gem::Specification.new do |s|
+    s.name        = "assert_value"
+    s.version     = "1.0"
+    s.author      = "Pluron, Inc."
+    s.email       = "support@pluron.com"
+    s.homepage    = "http://github.com/acunote/assert_value"
+    s.platform    = Gem::Platform::RUBY
+    s.license     = 'MIT'
+    s.description = "assert_value assertion"
+    s.summary     = "Assert that checks that two values (strings, expected and actual) are same and which can magically replace expected value with the actual in case the new behavior (and new actual value) is correct"
+
+    s.files         = `git ls-files`.split("\n")
+    s.test_files    = `git ls-files -- test/*`.split("\n")
+
+    s.require_path  = "lib"
+    s.has_rdoc      = true
+end

data/assert_value.kdev4

@@ -0,0 +1,3 @@
+[Project]
+Manager=KDevGenericManager
+Name=assert_value

data/lib/array_diff.rb

@@ -0,0 +1,331 @@
+class ArrayDiff
+
+  VERSION = 0.3
+
+  def ArrayDiff.lcs(a, b)
+    astart = 0
+    bstart = 0
+    afinish = a.length-1
+    bfinish = b.length-1
+    mvector = []
+    
+    # First we prune off any common elements at the beginning
+    while (astart <= afinish && bstart <= afinish && a[astart] == b[bstart])
+      mvector[astart] = bstart
+      astart += 1
+      bstart += 1
+    end
+    
+    # now the end
+    while (astart <= afinish && bstart <= bfinish && a[afinish] == b[bfinish])
+      mvector[afinish] = bfinish
+      afinish -= 1
+      bfinish -= 1
+    end
+
+    bmatches = b.reverse_hash(bstart..bfinish)
+    thresh = []
+    links = []
+    
+    (astart..afinish).each { |aindex|
+      aelem = a[aindex]
+      next unless bmatches.has_key? aelem
+      k = nil
+      bmatches[aelem].reverse.each { |bindex|
+    if k && (thresh[k] > bindex) && (thresh[k-1] < bindex)
+      thresh[k] = bindex
+    else
+      k = thresh.replacenextlarger(bindex, k)
+    end
+    links[k] = [ (k==0) ? nil : links[k-1], aindex, bindex ] if k
+      }
+    }
+
+    if !thresh.empty?
+      link = links[thresh.length-1]
+      while link
+    mvector[link[1]] = link[2]
+    link = link[0]
+      end
+    end
+
+    return mvector
+  end
+
+  def makediff(a, b)
+    mvector = ArrayDiff.lcs(a, b)
+    ai = bi = 0
+    while ai < mvector.length
+      bline = mvector[ai]
+      if bline
+    while bi < bline
+      discardb(bi, b[bi])
+      bi += 1
+    end
+    match(ai, bi)
+    bi += 1
+      else
+    discarda(ai, a[ai])
+      end
+      ai += 1
+    end
+    while ai < a.length
+      discarda(ai, a[ai])
+      ai += 1
+    end
+    while bi < b.length
+      discardb(bi, b[bi])
+      bi += 1
+    end
+    match(ai, bi)
+    1
+  end
+
+  def compactdiffs
+    diffs = []
+    @diffs.each { |df|
+      i = 0
+      curdiff = []
+      while i < df.length
+    whot = df[i][0]
+    s = @isstring ? df[i][2].chr : [df[i][2]]
+    p = df[i][1]
+    last = df[i][1]
+    i += 1
+    while df[i] && df[i][0] == whot && df[i][1] == last+1
+      s << df[i][2]
+      last  = df[i][1]
+      i += 1
+    end
+    curdiff.push [whot, p, s]
+      end
+      diffs.push curdiff
+    }
+    return diffs
+  end
+
+  attr_reader :diffs, :difftype
+
+  def initialize(diffs_or_a, b = nil, isstring = nil)
+    if b.nil?
+      @diffs = diffs_or_a
+      @isstring = isstring
+    else
+      @diffs = []
+      @curdiffs = []
+      makediff(diffs_or_a, b)
+      @difftype = diffs_or_a.class
+    end
+  end
+  
+  def match(ai, bi)
+    @diffs.push @curdiffs unless @curdiffs.empty?
+    @curdiffs = []
+  end
+
+  def discarda(i, elem)
+    @curdiffs.push ['-', i, elem]
+  end
+
+  def discardb(i, elem)
+    @curdiffs.push ['+', i, elem]
+  end
+
+  def compact
+    return Diff.new(compactdiffs)
+  end
+
+  def compact!
+    @diffs = compactdiffs
+  end
+
+  def inspect
+    @diffs.inspect
+  end
+
+  def diffrange(a, b)
+    if (a == b)
+      "#{a}"
+    else
+      "#{a},#{b}"
+    end
+  end
+
+  def to_diff
+    offset = 0
+    @diffs.each { |b|
+      first = b[0][1]
+      length = b.length
+      action = b[0][0]
+      addcount = 0
+      remcount = 0
+      b.each { |l| 
+        if l[0] == "+"
+          addcount += 1
+        elsif l[0] == "-"
+          remcount += 1
+        end
+      }
+      if addcount == 0
+        puts "#{diffrange(first+1, first+remcount)}d#{first+offset}"
+      elsif remcount == 0
+        puts "#{first-offset}a#{diffrange(first+1, first+addcount)}"
+      else
+        puts "#{diffrange(first+1, first+remcount)}c#{diffrange(first+offset+1, first+offset+addcount)}"
+      end
+      lastdel = (b[0][0] == "-")
+      b.each { |l|
+        if l[0] == "-"
+          offset -= 1
+          print "< "
+        elsif l[0] == "+"
+          offset += 1
+      if lastdel
+        lastdel = false
+            puts "---"
+          end
+          print "> "
+        end
+    print l[2]
+    print "\n"
+      }
+    }
+  end
+
+
+end
+
+module Diffable
+  def diff(b)
+    ArrayDiff.new(self, b)
+  end
+
+  # Create a hash that maps elements of the array to arrays of indices
+  # where the elements are found.
+
+  def reverse_hash(range = (0...self.length))
+    revmap = {}
+    range.each { |i|
+      elem = self[i]
+      if revmap.has_key? elem
+    revmap[elem].push i
+      else
+    revmap[elem] = [i]
+      end
+    }
+    return revmap
+  end
+
+  def replacenextlarger(value, high = nil)
+    high ||= self.length
+    if self.empty? || value > self[-1]
+      push value
+      return high
+    end
+    # binary search for replacement point
+    low = 0
+    while low < high
+      index = (high+low)/2
+      found = self[index]
+      return nil if value == found
+      if value > found
+    low = index + 1
+      else
+    high = index
+      end
+    end
+
+    self[low] = value
+    # $stderr << "replace #{value} : 0/#{low}/#{init_high} (#{steps} steps) (#{init_high-low} off )\n"
+    # $stderr.puts self.inspect
+    #gets
+    #p length - low
+    return low
+  end
+
+  def patch(diff)
+    newary = nil
+    if diff.difftype == String
+      newary = diff.difftype.new('')
+    else
+      newary = diff.difftype.new
+    end
+    ai = 0
+    bi = 0
+    diff.diffs.each { |d|
+      d.each { |mod|
+    case mod[0]
+    when '-'
+      while ai < mod[1]
+        newary << self[ai]
+        ai += 1
+        bi += 1
+      end
+      ai += 1
+    when '+'
+      while bi < mod[1]
+        newary << self[ai]
+        ai += 1
+        bi += 1
+      end
+      newary << mod[2]
+      bi += 1
+    else
+      raise "Unknown diff action"
+    end
+      }
+    }
+    while ai < self.length
+      newary << self[ai]
+      ai += 1
+      bi += 1
+    end
+    return newary
+  end
+end
+
+class Array
+  include Diffable
+end
+
+class String
+  include Diffable
+end
+
+=begin
+= ArrayDiff
+(({diff.rb})) - computes the differences between two arrays or
+strings. Copyright (C) 2001 Lars Christensen
+http://users.cybercity.dk/~dsl8950/ruby/diff.html
+
+== Synopsis
+
+    diff = ArrayDiff.new(a, b)
+    b = a.patch(diff)
+
+== Class ArrayDiff
+=== Class Methods
+--- ArrayDiff.new(a, b)
+--- a.diff(b)
+      Creates a Diff object which represent the differences between
+      ((|a|)) and ((|b|)). ((|a|)) and ((|b|)) can be either be arrays
+      of any objects, strings, or object of any class that include
+      module ((|Diffable|))
+
+== Module Diffable
+The module ((|Diffable|)) is intended to be included in any class for
+which differences are to be computed. Diffable is included into String
+and Array when (({diff.rb})) is (({require}))'d.
+
+Classes including Diffable should implement (({[]})) to get element at
+integer indices, (({<<})) to append elements to the object and
+(({ClassName#new})) should accept 0 arguments to create a new empty
+object.
+
+=== Instance Methods
+--- Diffable#patch(diff)
+      Applies the differences from ((|diff|)) to the object ((|obj|))
+      and return the result. ((|obj|)) is not changed. ((|obj|)) and
+      can be either an array or a string, but must match the object
+      from which the ((|diff|)) was created.
+=end

data/lib/assert_value.rb

@@ -0,0 +1,414 @@
+# Copyright (c) 2010-2011 Pluron, Inc.
+require 'test/unit/testcase'
+require 'text_diff'
+require 'pathname'
+
+$assert_value_options = []
+
+if RUBY_VERSION >= "1.9.0"
+
+    # Test/Unit from Ruby 1.9 can't accept additional options like it did in 1.8:
+    #   ruby test.rb -- --foo
+    # Now it has a strict option parser that considers all additional options as files.
+    # The right way to have an option now is to explicitly add it to Test/Unit parser.
+    module Test::Unit
+
+        module AssertValueOption
+            def setup_options(parser, options)
+                super
+                parser.on '--no-interactive', 'assert_value: non-interactive mode' do |flag|
+                    $assert_value_options << "--no-interactive"
+                end
+                parser.on '--no-canonicalize', 'assert_value: turn off canonicalization' do |flag|
+                    $assert_value_options << "--no-canonicalize"
+                end
+                parser.on '--autoaccept', 'assert_value: automatically accept new actual values' do |flag|
+                    $assert_value_options << "--autoaccept"
+                end
+            end
+
+            def non_options(files, options)
+                super
+            end
+        end
+
+        class Runner < MiniTest::Unit
+            include Test::Unit::AssertValueOption
+        end
+
+    end
+
+else
+
+    # In Ruby 1.8 additional test options are simply passed via ARGV
+    $assert_value_options << "--no-interactive" if ARGV.include?("--no-interactive")
+    $assert_value_options << "--no-canonicalize" if ARGV.include?("--no-canonicalize")
+    $assert_value_options << "--autoaccept" if ARGV.include?("--autoaccept")
+
+end
+
+
+#Use this to raise internal error with a given message
+#You can define your own method for your application
+unless defined? internal_error
+    def internal_error(message = 'internal error')
+        raise message
+    end
+end
+
+
+module AssertValueAssertion
+
+    def file_offsets
+      @file_offsets ||= Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    # assert_value: assert which checks that two strings (expected and actual) are same
+    # and which can "magically" replace expected value with the actual in case
+    # the new behavior (and new actual value) is correct
+    #
+    # == Usage ==
+    #
+    # Write this in the test source:
+    #     assert_value something, <<-END
+    #         foo
+    #         bar
+    #         zee
+    #     END
+    #
+    # You can also use assert_value for blocks. Then you can assert block result or raised exception
+    #    assert_value(<<-END) do
+    #        Exception NoMethodError: undefined method `+' for nil:NilClass
+    #    END
+    #        # Code block starts here
+    #        c = nil + 1
+    #    end
+    # 
+    # Then run tests as usual:
+    #    rake test:units
+    #    ruby test/unit/foo_test.rb
+    #    ...
+    #
+    # When assert_value fails, you'll be able to:
+    # - review diff
+    # - (optionally) accept new actual value (this modifies the test source file)
+    #
+    # Additional options for test runs:
+    # --no-interactive skips all questions and just reports failures
+    # --autoaccept prints diffs and automatically accepts all new actual values
+    # --no-canonicalize turns off expected and actual value canonicalization (see below for details)
+    #
+    # Additional options can be passed during both single test file run and rake test run:
+    #    In Ruby 1.8:
+    #    ruby test/unit/foo_test.rb -- --autoaccept
+    #    ruby test/unit/foo_test.rb -- --no-interactive
+    #
+    #    rake test TESTOPTS="-- --autoaccept"
+    #    rake test:units TESTOPTS="-- --no-canonicalize --autoaccept"
+    #
+    #    In Ruby 1.9:
+    #    ruby test/unit/foo_test.rb --autoaccept
+    #    ruby test/unit/foo_test.rb --no-interactive
+    #
+    #    rake test TESTOPTS="--autoaccept"
+    #    rake test:units TESTOPTS="--no-canonicalize --autoaccept"
+    #
+    #
+    # == Canonicalization ==
+    #
+    # Before comparing expected and actual strings, assert_value canonicalizes both using these rules:
+    # - indentation is ignored (except for indentation
+    #   relative to the first line of the expected/actual string)
+    # - ruby-style comments after "#" are ignored: 
+    #   both whole-line and end-of-line comments are supported
+    # - empty lines are ignored
+    # - trailing whitespaces are ignored
+    #
+    # You can turn canonicalization off with --no-canonicalize option. This is useful
+    # when you need to regenerate expected test strings.
+    # To regenerate the whole test suite, run:
+    #    In Ruby 1.8:
+    #    rake test TESTOPTS="-- --no-canonicalize --autoaccept"
+    #    In Ruby 1.9:
+    #    rake test TESTOPTS="--no-canonicalize --autoaccept"
+    #
+    # Example of assert_value with comments:
+    #  assert_value something, <<-END
+    #      # some tree
+    #      foo 1
+    #        foo 1.1
+    #        foo 1.2    # some node
+    #      bar 2
+    #        bar 2.1
+    #  END
+    #
+    #
+    #
+    # == Umportant Usage Rules ==
+    #
+    # Restrictions:
+    # - only END and EOS are supported as end of string sequence
+    # - it's a requirement that you have <<-END at the same line as assert_value
+    # - assert_value can't be within a block
+    #
+    # Storing expected output in files:
+    # - assert_value something, :log => <path_to_file>
+    # - path to file is relative to:
+    #   - RAILS_ROOT (if that is defined)
+    #   - current dir (if no RAILS_ROOT is defined)
+    # - file doesn't have to exist, it will be created if necessary
+    #
+    # Misc:
+    # - it's ok to have several assert_value's in the same test method, assert_value.
+    #   correctly updates all assert_value's in the test file
+    # - it's ok to omit expected string, like this:
+    #       assert_value something
+    #   in fact, this is the preferred way to create assert_value tests - you write empty
+    #   assert_value, run tests and they will fill expected values for you automatically
+    def assert_value(*args)
+        if block_given?
+            mode = :block
+            expected = args[0]
+            actual = ""
+            begin
+                actual = yield.to_s
+            rescue Exception => e
+                actual = "Exception #{e.class}: #{e.message}"
+            end
+        else
+            mode = :scalar
+            expected = args[1]
+            actual = args[0]
+        end
+
+        if expected.nil?
+            expected = ""
+            change = :create_expected_string
+        elsif expected.class == String
+            change = :update_expected_string
+        elsif expected.class == Hash
+            raise ":log key is missing" unless expected.has_key? :log
+            log_file = expected[:log]
+            if defined? RAILS_ROOT
+                log_file = File.expand_path(log_file, RAILS_ROOT)
+            else
+                log_file = File.expand_path(log_file, Dir.pwd)
+            end
+            expected = File.exists?(log_file) ? File.read(log_file) : ""
+            change = :update_file_with_expected_string
+        else
+            internal_error("Invalid expected class #{excepted.class}")
+        end
+
+        # interactive mode is turned on by default, except when
+        # - --no-interactive is given
+        # - CIRCLECI is set (CircleCI captures test output, but doesn't interact with user)
+        # - STDIN is not a terminal device (i.e. we can't ask any questions)
+        interactive = !$assert_value_options.include?("--no-interactive") && !ENV["CIRCLECI"] && STDIN.tty?
+        canonicalize = !$assert_value_options.include?("--no-canonicalize")
+        autoaccept = $assert_value_options.include?("--autoaccept")
+
+        is_same_canonicalized, is_same, diff_canonicalized, diff = compare_for_assert_value(expected, actual)
+
+        if (canonicalize and !is_same_canonicalized) or (!canonicalize and !is_same)
+            diff_to_report = canonicalize ? diff_canonicalized : diff
+            if interactive
+                # print method name and short backtrace
+                soft_fail(diff_to_report)
+
+                if autoaccept
+                    accept = true
+                else
+                    print "Accept the new value: yes to all, no to all, yes, no? [Y/N/y/n] (y): "
+                    STDOUT.flush
+                    response = STDIN.gets.strip
+                    accept = ["", "y", "Y"].include? response
+                    $assert_value_options << "--autoaccept" if response == "Y"
+                    $assert_value_options << "--no-interactive" if response == "N"
+                end
+
+                if accept
+                    if [:create_expected_string, :update_expected_string].include? change
+                        accept_string(actual, change, mode)
+                    elsif change == :update_file_with_expected_string
+                        accept_file(actual, log_file)
+                    else
+                        internal_error("Invalid change #{change}")
+                    end
+                end
+            end
+            if accept
+                # when change is accepted, we should not report it as a failure because
+                # we want the test method to continue executing (in case there're more
+                # assert_value's in the method)
+                succeed
+            else
+                fail(diff)
+            end
+        else
+            succeed
+        end
+    end
+
+private
+
+    def succeed
+        if RUBY_VERSION < "1.9.0"
+            add_assertion
+        else
+            true
+        end
+    end
+
+    def soft_fail(diff)
+        if RUBY_VERSION < "1.9.0"
+            failure = Test::Unit::Failure.new(name, filter_backtrace(caller(0)), diff)
+            puts "\n#{failure}"
+        else
+            failure = MiniTest::Assertion.new(diff)
+            puts "\n#{failure}"
+        end
+    end
+
+    def fail(diff)
+        if RUBY_VERSION < "1.9.0"
+            raise Test::Unit::AssertionFailedError.new(diff)
+        else
+            raise MiniTest::Assertion.new(diff)
+        end
+    end
+
+    # actual - actual value of the scalar or result of the executed block
+    # change - what to do with expected value (:create_expected_string or :update_expected_string)
+    # mode   - describes signature of assert_value call by type of main argument (:block or :scalar)
+    def accept_string(actual, change, mode)
+        file, method, line = get_caller_location(:depth => 3)
+
+        # read source file, construct the new source, replacing everything
+        # between "do" and "end" in assert_value's block
+        # using File::expand_path here because "file" can be either
+        # absolute path (when test is run with "rake test" runs)
+        # or relative path (when test is run via ruby <path_to_test_file>)
+        source = File.readlines(File::expand_path(file))
+
+        # file may be changed by previous accepted assert_value's, adjust line numbers
+        offset = file_offsets[file].keys.inject(0) do |sum, i|
+            line.to_i >= i ? sum + file_offsets[file][i] : sum
+        end
+
+        expected_text_end_line = expected_text_start_line = line.to_i + offset
+        if change == :update_expected_string
+            #search for the end of expected value in code
+            expected_text_end_line += 1 while !["END", "EOS"].include?(source[expected_text_end_line].strip)
+        elsif change == :create_expected_string
+            # The is no expected value yet. expected_text_end_line is unknown
+        else
+            internal_error("Invalid change #{change}")
+        end
+
+        expected_length = expected_text_end_line - expected_text_start_line
+
+        # indentation is the indentation of assert_value call + 4
+        indentation = source[expected_text_start_line-1] =~ /^(\s+)/ ? $1.length : 0
+        indentation += 4
+
+        if change == :create_expected_string 
+            if mode == :scalar
+                # add second argument to assert_value if it's omitted
+                source[expected_text_start_line-1] = "#{source[expected_text_start_line-1].chop}, <<-END\n"
+            elsif mode == :block
+                # add expected value as argument to assert_value before block call
+                source[expected_text_start_line-1] = source[expected_text_start_line-1].sub(/assert_value(\(.*?\))*/, "assert_value(<<-END)")
+            else
+                internal_error("Invalid mode #{mode}")
+            end
+        end
+        source = source[0, expected_text_start_line] +
+            actual.split("\n").map { |l| "#{" "*(indentation)}#{l}\n"} +
+            (change == :create_expected_string ? ["#{" "*(indentation-4)}END\n"] : [])+
+            source[expected_text_end_line, source.length]
+
+        # recalculate line number adjustments
+        actual_length = actual.split("\n").length
+        actual_length += 1 if change == :create_expected_string # END marker after expected value
+        file_offsets[file][line.to_i] = actual_length - expected_length
+
+        source_file = File.open(file, "w+")
+        source_file.write(source.join(''))
+        source_file.fsync
+        source_file.close
+    end
+
+    def accept_file(actual, log_file)
+        log = File.open(log_file, "w+")
+        log.write(actual)
+        log.fsync
+        log.close
+    end
+
+    def compare_for_assert_value(expected_verbatim, actual_verbatim)
+        expected_canonicalized, expected = canonicalize_for_assert_value(expected_verbatim)
+        actual_canonicalized, actual = canonicalize_for_assert_value(actual_verbatim)
+        diff_canonicalized = AssertValue::TextDiff.array_diff(expected_canonicalized, actual_canonicalized)
+        diff = AssertValue::TextDiff.array_diff(expected, actual)
+        [expected_canonicalized == actual_canonicalized, expected == actual, diff_canonicalized, diff]
+    end
+
+    def canonicalize_for_assert_value(text)
+        # make array of lines out of the text
+        result = text.split("\n")
+
+        # ignore leading newlines if any (trailing will be automatically ignored by split())
+        result.delete_at(0) if result[0] == ""
+
+        indentation = $1.length if result[0] and result[0] =~ /^(\s+)/
+
+        result.map! do |line|
+            # ignore indentation: we assume that the first line defines indentation
+            line.gsub!(/^\s{#{indentation}}/, '') if indentation
+            # ignore trailing spaces
+            line.gsub(/\s*$/, '')
+        end
+
+        # ignore comments
+        result_canonicalized= result.map do |line|
+            line.gsub(/\s*(#.*)?$/, '')
+        end
+        # ignore blank lines (usually they are lines with comments only)
+        result_canonicalized.delete_if { |line| line.nil? or line.empty? }
+
+        [result_canonicalized, result]
+    end
+
+    def get_caller_location(options = {:depth => 2})
+        caller_method = caller(options[:depth])[0]
+
+        #Sample output is:
+        #either full path when run as "rake test"
+        #   /home/user/assert_value/test/unit/assure_test.rb:9:in `test_assure
+        #or relative path when run as ruby test/unit/assure_test.rb
+        #   test/unit/assure_test.rb:9:in `test_assure
+        caller_method =~ /([^:]+):([0-9]+):in `(.+)'/
+        file = $1
+        line = $2
+        method = $3
+        [file, method, line]
+    end
+
+end
+
+if RUBY_VERSION >= "1.9.0"
+    class MiniTest::Unit::TestCase
+        include AssertValueAssertion
+    end
+else
+    class Test::Unit::TestCase
+        include AssertValueAssertion
+    end
+end
+
+if defined?(RSpec)
+    RSpec.configure do |c|
+        c.include AssertValueAssertion
+    end
+end

data/lib/text_diff.rb

@@ -0,0 +1,109 @@
+# Copyright (c) 2008 Pluron, Inc.
+
+require 'array_diff'
+
+module AssertValue
+
+class TextDiff
+
+    def self.mapped_chunk(arr, from, to)
+        return [] if to < from
+        arr[from, to-from+1].map{|x| [' ', x]}
+    end
+
+    def self.chunk(arr, from, to)
+        result = []
+        if to - from > 2
+            result += self.mapped_chunk(arr, from, from+2) if from > 0
+            result << ['@', to-2]
+            result += self.mapped_chunk(arr, to-2, to)
+        else 
+            result << ['@', from] if from == 0
+            result += self.mapped_chunk(arr, from, to)
+        end
+    end
+
+    def self.record_stat(arr, at, remcount, addcount, linecount, offset)
+        index = arr[at][1]+1
+        ['', "@@ -#{index},#{linecount-addcount}, +#{index+offset},#{linecount-remcount} @@"]
+    end
+
+    def self.diff(a_text, b_text)
+        a = a_text.split("\n")
+        b = b_text.split("\n")
+        self.array_diff(a, b)
+    end
+
+    def self.array_diff(a, b)
+        diff = ArrayDiff.new(a, b)
+
+        return nil if diff.diffs.empty?
+
+        result = []
+
+        from = to = nextfrom = 0
+        offset = 0
+        diff.diffs.each do |tuple|
+            first = tuple[0][1]
+            length = tuple.length
+            action = tuple[0][0]
+            addcount = 0
+            remcount = 0
+            tuple.each do |l| 
+                if l[0] == "+"
+                    addcount += 1
+                elsif l[0] == "-"
+                    remcount += 1
+                end
+            end
+            if remcount == 0
+                to = first-offset-1
+                nextfrom = to+1
+            else
+                to = first-1
+                nextfrom = to+remcount+1
+            end
+            result += self.chunk(a, from, to)
+            from = nextfrom
+            lastdel = (tuple[0][0] == "-")
+            tuple.each do |l|
+                if l[0] == "-"
+                    offset -= 1
+                else
+                    offset += 1
+                end
+                result << [l[0], l[2]]
+            end
+        end
+        if (a.length - from) > 2
+            result += self.chunk(a, from, from+2)
+        elsif a.length > 0
+            result += self.chunk(a, from, a.length-1)
+        end
+        linecount = addcount = remcount = offset = current_offset = 0
+        info_index = nil
+        result.each_with_index do |l, i|
+            if l[0] == '@'
+                result[info_index] = self.record_stat(result, info_index, remcount, addcount, 
+                    linecount, offset) if info_index
+                info_index = i
+                offset += addcount - remcount
+                linecount = 0
+                addcount = remcount = 0
+            elsif l[0] == '-'
+                remcount += 1
+                linecount += 1
+            elsif l[0] == '+'
+                addcount += 1
+                linecount += 1
+            else
+                linecount += 1
+            end
+        end
+        result[info_index] = self.record_stat(result, info_index, remcount, addcount, linecount, offset) if info_index
+        return result.map{|x| x.join('')}.join("\n")
+    end
+
+end
+
+end

data/test/assert_value_spec.rb

@@ -0,0 +1,28 @@
+require 'assert_value'
+
+describe "Assert Value" do
+
+  it "compares with value in file" do
+    assert_value("foo", :log => 'test/logs/assert_value_with_files.log.ref')
+    expect(assert_value("foo", :log => 'test/logs/assert_value_with_files.log.ref')).to eq(true)
+  end
+
+  it "compares with value inlined in source file" do
+    assert_value "foo", <<-END
+        foo
+    END
+
+    expect(
+      assert_value "foo", <<-END
+          foo
+      END
+    ).to eq(true)
+
+    expect(assert_value(<<-END) do
+        foo
+    END
+      "foo"
+    end).to eq(true)
+  end
+
+end

data/test/assert_value_test.rb

@@ -0,0 +1,101 @@
+# Copyright (c) 2011 Pluron, Inc.
+
+require 'test/unit'
+require 'assert_value'
+
+class AssertValueTest < Test::Unit::TestCase
+
+    def test_basic_assert_value
+        assert_value "foo", <<-END
+            foo
+        END
+    end
+
+    def test_assert_value_with_files
+        assert_value "foo", :log => 'test/logs/assert_value_with_files.log.ref'
+    end
+
+    def test_assert_value_empty_string
+        # These two calls are the same
+        assert_value ""
+        assert_value "", <<-END
+        END
+    end
+
+    def test_assert_value_exception
+        assert_value(<<-END) do
+            Exception NoMethodError: undefined method `+' for nil:NilClass
+        END
+            nil + 1
+        end
+    end
+
+    def test_assert_value_for_block_value
+        assert_value(<<-END) do
+            All Ok!
+        END
+            a = "All Ok!"
+        end
+    end
+
+    def test_assert_value_exception_with_files
+        assert_value(:log => 'test/logs/assert_value_exception_with_files.log.ref') do
+            nil + 1
+        end
+    end
+
+    def test_assert_value_block_alternative_syntax
+        assert_value(<<-END) {
+            Exception NoMethodError: undefined method `+' for nil:NilClass
+        END
+            nil + 1
+        }
+    end
+
+    def test_assert_value_block_alternative_syntax_one_liner
+        assert_value(<<-END) { nil + 1 }
+            Exception NoMethodError: undefined method `+' for nil:NilClass
+        END
+    end
+
+    def test_assert_value_for_empty_block
+        # These calls are the same
+        assert_value { }
+
+        assert_value do end
+
+        assert_value(<<-END) { }
+        END
+
+        assert_value(<<-END) do end
+        END
+    end
+
+    def test_assert_value_for_nil_block_result
+        # These calls are the same
+        assert_value { nil }
+
+        assert_value do nil end
+
+        assert_value(<<-END) { nil }
+        END
+
+        assert_value(<<-END) do nil end
+        END
+    end
+
+end
+
+if RUBY_VERSION >= "1.9.0"
+
+class AssertValueMiniTest < MiniTest::Unit::TestCase
+
+    def test_basic_assert_value
+        assert_value "foo", <<-END
+            foo
+        END
+    end
+
+end
+
+end

data/test/logs/assert_value_exception_with_files.log.ref

@@ -0,0 +1 @@
+Exception NoMethodError: undefined method `+' for nil:NilClass

data/test/logs/assert_value_with_files.log.ref

@@ -0,0 +1 @@
+foo

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: assert_value
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Pluron, Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-24 00:00:00.000000000 Z
+dependencies: []
+description: assert_value assertion
+email: support@pluron.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- assert_value.gemspec
+- assert_value.kdev4
+- lib/array_diff.rb
+- lib/assert_value.rb
+- lib/text_diff.rb
+- test/assert_value_spec.rb
+- test/assert_value_test.rb
+- test/logs/assert_value_exception_with_files.log.ref
+- test/logs/assert_value_with_files.log.ref
+homepage: http://github.com/acunote/assert_value
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Assert that checks that two values (strings, expected and actual) are same
+  and which can magically replace expected value with the actual in case the new behavior
+  (and new actual value) is correct
+test_files:
+- test/assert_value_spec.rb
+- test/assert_value_test.rb
+- test/logs/assert_value_exception_with_files.log.ref
+- test/logs/assert_value_with_files.log.ref