sub_diff 0.0.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 68d94bfc8c4cdd97c0ad2830274f3e62aac1703f
+  data.tar.gz: 9e3d83376c646399983352017abd0ed848d5c8ff
+SHA512:
+  metadata.gz: 3326572008e2952db12ea5c5701c35bf9acdf8d2d0c54b304d722d727e1ec01a46933259d0c0c27756098f6e09fceef811b182ba2acd75d053214f8bbb22ab09
+  data.tar.gz: a45b5a88dbf77f7ae0667f9a0864b00fc2dffa8db331e2ca03435af66c2d0432f99d9be97edb3875d839cd7d4bc7a1d5c40810f758fd4a8fabf126b49cf12285

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+rdoc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,13 @@
+addons:
+  code_climate:
+    repo_token: 6f133fcc28caad1e1099287a1ac4ee0ac4fb428cdd9c5cb9424be1110ef8704a
+
+install: bundle install --jobs 3 --retry 3
+
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+
+script: bundle exec rspec

data/Gemfile

@@ -1,8 +1,7 @@
-source 'http://www.rubygems.org'
+source 'https://www.rubygems.org'
 
 gemspec
 
-group :test do
-  gem 'rake'
-  gem 'rdoc', '>= 2.4.2'
-end
+unless RUBY_VERSION =~ /1\.8\./
+  gem 'codeclimate-test-reporter'
+end

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    sub_diff (1.0.0)
+
+GEM
+  remote: https://www.rubygems.org/
+  specs:
+    codeclimate-test-reporter (0.4.7)
+      simplecov (>= 0.7.1, < 1.0.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    multi_json (1.11.0)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.2)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    simplecov (0.9.2)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.9.0)
+    simplecov-html (0.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  codeclimate-test-reporter
+  rspec
+  sub_diff!

data/{MIT-LICENSE → LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Sean Huber - shuber@huberry.com
+Copyright (c) 2011 Sean Huber - github@shuber.io
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +17,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+# [![Sean Huber](https://cloud.githubusercontent.com/assets/2419/6550752/832d9a64-c5ea-11e4-9717-6f9aa6e023b5.png)](https://github.com/shuber) sub_diff
+
+[![Build Status](https://secure.travis-ci.org/shuber/sub_diff.svg)](http://travis-ci.org/shuber/sub_diff) [![Code Climate](https://codeclimate.com/github/shuber/sub_diff/badges/gpa.svg)](https://codeclimate.com/github/shuber/sub_diff) [![Coverage](https://codeclimate.com/github/shuber/sub_diff/badges/coverage.svg)](https://codeclimate.com/github/shuber/sub_diff) [![Gem Version](https://badge.fury.io/rb/sub_diff.svg)](http://badge.fury.io/rb/sub_diff)
+
+Inspect the changes of your [`String#sub`] and [`String#gsub`] replacements.
+
+[`String#sub`]: http://ruby-doc.org//core-2.2.0/String.html#method-i-sub
+[`String#gsub`]: http://ruby-doc.org//core-2.2.0/String.html#method-i-gsub
+
+## Installation
+
+```
+gem install sub_diff
+```
+
+
+## Requirements
+
+Ruby 1.8.7+
+
+
+## Usage
+
+This gem introduces a couple new methods to [`String`](http://ruby-doc.org/core-2.2.0/String.html) objects.
+
+* [`String#sub_diff`](http://ruby-doc.org/core-2.2.0/String.html#method-i-sub)
+* [`String#gsub_diff`](http://ruby-doc.org/core-2.2.0/String.html#method-i-gsub)
+
+These methods accept the same arguments as their `sub` and `gsub` counterparts.
+
+```ruby
+replaced = 'this is a test'.gsub_diff(/(\S*is)/, 'replaced(\1)') #=> #<DiffCollection:0x007fc532049508>
+```
+
+The difference is that it returns a `DiffCollection` instead. This object behaves just like a `String`.
+
+```ruby
+puts replaced #=> "replaced(this) replaced(is) a test"
+```
+
+But it also allows us to check if the replacement actually *changed* anything.
+
+```ruby
+replaced.changed? #=> true
+```
+
+For a closer look at the changes, we can iterate thru each `Diff` in the replacment.
+
+```ruby
+replaced.each do |diff|
+  puts diff.inspect
+end
+
+#=> "replaced(this)"
+#=> " "
+#=> "replaced(is)"
+#=> " a test"
+```
+
+Each `Diff` object behaves just like a string, but also includes a few additional methods.
+
+```ruby
+replaced.each do |diff|
+  puts "    value: #{diff.value.inspect}"
+  puts "value_was: #{diff.value_was.inspect}"
+  puts " changed?: #{diff.changed?}"
+end
+
+#=>     value: "replaced(this)"
+#=> value_was: "this"
+#=>  changed?: true
+
+#=>     value: " "
+#=> value_was: " "
+#=>  changed?: false
+
+#=>     value: "replaced(is)"
+#=> value_was: "is"
+#=>  changed?: true
+
+#=>     value: " a test"
+#=> value_was: " a test"
+#=>  changed?: false
+```
+
+
+## API
+
+[YARD Documentation](http://www.rubydoc.info/github/shuber/sub_diff)
+
+* `Diff#changed?`
+* `Diff#value`
+* `Diff#value_was`
+* `DiffCollection#changed?`
+* `DiffCollection#diffs`
+* `DiffCollection#each`
+* `DiffCollection#size`
+
+## Testing
+
+```
+bundle exec rspec
+```
+
+
+## Contributing
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with the version or history.
+* Send me a pull request. Bonus points for topic branches.
+
+
+## License
+
+[MIT](https://github.com/shuber/sub_diff/blob/master/LICENSE)  - Copyright © 2011 Sean Huber

data/lib/sub_diff/core_ext/string.rb

@@ -0,0 +1,15 @@
+require 'sub_diff/diff_builder'
+
+module SubDiff
+  module CoreExt
+    module String
+      def sub_diff(*args, &block)
+        DiffBuilder.new(self, :sub).diff(*args, &block)
+      end
+
+      def gsub_diff(*args, &block)
+        DiffBuilder.new(self, :gsub).diff(*args, &block)
+      end
+    end
+  end
+end

data/lib/sub_diff/diff.rb

@@ -1,22 +1,22 @@
+require 'delegate'
+
 module SubDiff
-  class Diff
-    attr_reader :value, :value_was
-    alias_method :to_s, :value
+  class Diff < SimpleDelegator
+    attr_reader :value_was
+
+    alias_method :value, :__getobj__
 
     def initialize(value, value_was = nil)
-      @value, @value_was = value, value_was || value
+      @value_was = value_was || value
+      super(value)
     end
 
     def changed?
-      @changed ||= value != value_was
-    end
-
-    def method_missing(*args, &block)
-      to_s.send(*args, &block)
+      value != value_was
     end
 
-    def respond_to_missing?(method, include_private)
-      to_s.respond_to?(method, include_private)
+    def empty?
+      value.empty? && !changed?
     end
   end
-end
+end

data/lib/sub_diff/diff_builder.rb

@@ -0,0 +1,34 @@
+require 'forwardable'
+require 'sub_diff/diff_collection'
+require 'sub_diff/differ'
+require 'sub_diff/gsub'
+
+module SubDiff
+  class DiffBuilder < Struct.new(:string, :type)
+    extend Forwardable
+
+    def_delegators :instance, :diff
+
+    private
+
+    def instance
+      builder.new(differ)
+    end
+
+    def builder
+      Module.nesting.last.const_get(constant)
+    end
+
+    def constant
+      type.to_s.capitalize
+    end
+
+    def differ
+      Differ.new(collection, type)
+    end
+
+    def collection
+      DiffCollection.new(string)
+    end
+  end
+end

data/lib/sub_diff/diff_collection.rb

@@ -1,38 +1,43 @@
+require 'delegate'
+require 'forwardable'
+require 'sub_diff/diff'
+
 module SubDiff
-  class DiffCollection
+  class DiffCollection < SimpleDelegator
+    extend Forwardable
     include Enumerable
 
-    def initialize(diffs = [])
-      @diffs = []
-      diffs.each { |diff| self << diff }
-    end
+    attr_reader :string, :diffs
 
-    def <<(diff)
-      if diff.changed? || !diff.empty?
-        @diffs << diff
-        @to_s = nil
-      end
-      self
-    end
+    def_delegators :diffs, :each, :size
 
-    def each(&block)
-      @diffs.each(&block)
+    def initialize(string)
+      @string = string
+      @diffs = []
+      super(string)
     end
 
-    def method_missing(*args, &block)
-      to_s.send(*args, &block)
+    def changed?
+      diffs.any?(&:changed?)
     end
 
-    def respond_to_missing?(method, include_private)
-      to_s.respond_to?(method, include_private)
-    end
+    def push(*args)
+      if args.compact.any?
+        diff = Diff.new(*args)
+        append(diff)
+      end
 
-    def size
-      @diffs.size
+      self
     end
+    alias_method :<<, :push
+
+    private
 
-    def to_s
-      @to_s ||= @diffs.join
+    def append(diff)
+      unless diff.empty?
+        diffs << diff
+        __setobj__(diffs.join)
+      end
     end
   end
-end
+end

data/lib/sub_diff/differ.rb

@@ -0,0 +1,22 @@
+module SubDiff
+  class Differ < Struct.new(:diff_collection, :diff_method)
+    def diff(*args)
+      # Ruby 1.8.7 does not support additional args after * (splat)
+      block = args.pop
+
+      differ.call(args.first) do |match|
+        diff = { :match => match, :prefix => $`, :suffix => $' }
+        diff[:replacement] = match.sub(*args, &block)
+        yield(diff_collection, diff)
+      end
+
+      diff_collection
+    end
+
+    private
+
+    def differ
+      diff_collection.string.method(diff_method)
+    end
+  end
+end

data/lib/sub_diff/gsub.rb

@@ -0,0 +1,29 @@
+require 'sub_diff/sub'
+
+module SubDiff
+  class Gsub < Sub
+    private
+
+    def diff!(_builder, diff, _search)
+      super
+      last_prefix << prefix(diff) << diff[:match]
+    end
+
+    def last_prefix
+      @last_prefix ||= ''
+    end
+
+    def prefix(_diff)
+      super.sub(last_prefix, '')
+    end
+
+    def suffix(_diff, search)
+      matcher = suffix_matcher(search)
+      super unless super.send(matcher, search)
+    end
+
+    def suffix_matcher(search)
+      search.is_a?(Regexp) ? :match : :include?
+    end
+  end
+end

data/lib/sub_diff/sub.rb

@@ -0,0 +1,28 @@
+module SubDiff
+  class Sub < Struct.new(:differ)
+    def diff(*args, &block)
+      # Ruby 1.8.7 does not support additional args after * (splat)
+      args.push(block)
+
+      differ.diff(*args) do |builder, diff|
+        diff!(builder, diff, args.first)
+      end
+    end
+
+    private
+
+    def diff!(builder, diff, search)
+      builder << prefix(diff)
+      builder.push(diff[:replacement], diff[:match])
+      builder << suffix(diff, search)
+    end
+
+    def prefix(diff)
+      diff[:prefix]
+    end
+
+    def suffix(diff, _search)
+      diff[:suffix]
+    end
+  end
+end

data/lib/sub_diff/version.rb

@@ -1,17 +1,3 @@
 module SubDiff
-  # Contains information about this gem's version
-  module Version
-    MAJOR = 0
-    MINOR = 0
-    PATCH = 0
-
-    # Returns a version string by joining <tt>MAJOR</tt>, <tt>MINOR</tt>, and <tt>PATCH</tt> with <tt>'.'</tt>
-    #
-    # Example
-    #
-    #   puts Version # '1.0.2'
-    def self.to_s
-      [MAJOR, MINOR, PATCH].join('.')
-    end
-  end
-end
+  VERSION = '1.0.0'
+end

data/lib/sub_diff.rb

@@ -1,39 +1,4 @@
-require 'respond_to_missing'
+require 'sub_diff/core_ext/string'
+require 'sub_diff/version'
 
-module SubDiff
-  autoload :Diff,           'sub_diff/diff'
-  autoload :DiffCollection, 'sub_diff/diff_collection'
-  autoload :Version,        'sub_diff/version'
-
-  def gsub_diff(*args, &block)
-    with_diff_collection do |diff_collection|
-      match_prefix, suffix_matcher = '', args.first.is_a?(Regexp) ? :match : :include?
-      gsub(args.first) do |match|
-        suffix, prefix, replacement = Diff.new($'), Diff.new($`.sub(match_prefix, '')), Diff.new(match.sub(*args, &block), match)
-        diff_collection << prefix << replacement
-        diff_collection << suffix unless suffix.send(suffix_matcher, args.first)
-        match_prefix << prefix + match
-      end
-    end
-  end
-
-  def sub_diff(*args, &block)
-    with_diff_collection do |diff_collection|
-      sub(args.first) do |match|
-        suffix, prefix, replacement = Diff.new($'), Diff.new($`), Diff.new(match.sub(*args, &block), match)
-        diff_collection << prefix << replacement << suffix
-      end
-    end
-  end
-
-  protected
-
-    def with_diff_collection
-      diff_collection = DiffCollection.new
-      yield diff_collection
-      diff_collection << Diff.new(self) if diff_collection.empty?
-      diff_collection
-    end
-end
-
-String.send(:include, SubDiff)
+String.send(:include, SubDiff::CoreExt::String)

data/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+begin
+  if ENV['CODECLIMATE_REPO_TOKEN']
+    require 'codeclimate-test-reporter'
+    CodeClimate::TestReporter.start
+  else
+    require 'simplecov'
+    SimpleCov.start { add_filter('/vendor/bundle/') }
+  end
+rescue LoadError
+  # Ignore when testing with Ruby 1.8.7
+end
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.raise_errors_for_deprecations!
+  config.run_all_when_everything_filtered = true
+end
+
+# RSpec matcher to spec delegations.
+# Forked from https://gist.github.com/ssimeonov/5942729 with fixes
+# for arity + custom prefix.
+#
+# Usage:
+#
+#     describe Post do
+#       it { should delegate(:name).to(:author).with_prefix } # post.author_name
+#       it { should delegate(:name).to(:author).with_prefix(:any) } # post.any_name
+#       it { should delegate(:month).to(:created_at) }
+#       it { should delegate(:year).to(:created_at) }
+#       it { should delegate(:something).to(:'@instance_var') }
+#     end
+RSpec::Matchers.define :delegate do |method|
+  match do |delegator|
+    @prefix ||= nil
+    @method = @prefix ? :"#{@prefix}_#{method}" : method
+    @delegator = delegator
+
+    if @to.to_s[0] == '@'
+      # Delegation to an instance variable
+      old_value = @delegator.instance_variable_get(@to)
+      begin
+        @delegator.instance_variable_set(@to, receiver_double(method))
+        @delegator.send(@method) == :called
+      ensure
+        @delegator.instance_variable_set(@to, old_value)
+      end
+    elsif @delegator.respond_to?(@to, true)
+      unless [0,-1].include?(@delegator.method(@to).arity)
+        raise "#{@delegator}'s' #{@to} method does not have zero or -1 arity (it expects parameters)"
+      end
+      allow(@delegator).to receive(@to).and_return(receiver_double(method))
+      @delegator.send(@method) == :called
+    else
+      raise "#{@delegator} does not respond to #{@to}"
+    end
+  end
+
+  description do
+    "delegate :#{@method} to its #{@to}#{@prefix ? ' with prefix' : ''}"
+  end
+
+  failure_message do |text|
+    "expected #{@delegator} to delegate :#{@method} to its #{@to}#{@prefix ? ' with prefix' : ''}"
+  end
+
+  failure_message_when_negated do |text|
+    "expected #{@delegator} not to delegate :#{@method} to its #{@to}#{@prefix ? ' with prefix' : ''}"
+  end
+
+  chain(:to) { |receiver| @to = receiver }
+  chain(:with_prefix) { |prefix| @prefix = prefix || @to }
+
+  def receiver_double(method)
+    double('receiver').tap do |receiver|
+      allow(receiver).to receive(method).and_return(:called)
+    end
+  end
+end

data/spec/sub_diff/diff_collection_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path('../../../lib/sub_diff/diff_collection', __FILE__)
+
+RSpec.describe SubDiff::DiffCollection do
+  subject { described_class.new(diffable) }
+
+  let(:diffable) { 'this is a simple test' }
+
+  describe '#changed?' do
+    it 'should return true if any diffs have changed' do
+      subject.push('one', 'two')
+      expect(subject).to be_changed
+    end
+
+    it 'should return false if no diffs have changed' do
+      subject.push('same', 'same')
+      expect(subject).not_to be_changed
+    end
+
+    it 'should return false if there are no diffs' do
+      expect(subject).not_to be_changed
+    end
+  end
+
+  describe '#each' do
+    it { is_expected.to be_an(Enumerable) }
+    it { is_expected.to delegate(:each).to(:diffs) }
+  end
+
+  describe '#push' do
+    it 'should return self' do
+      expect(subject.push).to eq(subject)
+    end
+
+    it 'should append an unchanged diff' do
+      block = proc { subject.push('unchanged') }
+      expect(block).to change(subject.diffs, :size)
+    end
+
+    it 'should append a changed diff' do
+      block = proc { subject.push('now', 'was') }
+      expect(block).to change(subject.diffs, :size)
+    end
+
+    it 'should not append a nil diff' do
+      block = proc { subject.push(nil) }
+      expect(block).not_to change(subject.diffs, :size)
+    end
+
+    it 'should not append an empty diff' do
+      block = proc { subject.push('') }
+      expect(block).not_to change(subject.diffs, :size)
+    end
+  end
+
+  describe '#size' do
+    it { is_expected.to delegate(:size).to(:diffs) }
+
+    it 'should not use the string size' do
+      expect(subject.size).not_to eq(subject.to_s.size)
+    end
+  end
+
+  describe '#__getobj__' do
+    it 'should join the diff values if any' do
+      subject.push('test')
+      subject.push('example')
+      expect(subject.__getobj__).to eq('testexample')
+    end
+
+    it 'should return the diffable if diffs are empty' do
+      expect(subject.__getobj__).to eq(diffable)
+    end
+  end
+end

data/spec/sub_diff/diff_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../../lib/sub_diff/diff', __FILE__)
+
+RSpec.describe SubDiff::Diff do
+  let(:diff)                   { described_class.new(value, value_was) }
+  let(:diff_without_value_was) { described_class.new(value) }
+  let(:diff_with_empty_values) { described_class.new('', '') }
+
+  let(:value)     { 'test' }
+  let(:value_was) { 'testing' }
+
+  describe '#changed?' do
+    it 'should return true if value does not match value_was' do
+      expect(diff).to be_changed
+    end
+
+    it 'should return false if value matches value_was' do
+      expect(diff_without_value_was).not_to be_changed
+      expect(diff_with_empty_values).not_to be_changed
+    end
+  end
+
+  describe '#empty?' do
+    it 'should return false if the diff was changed' do
+      expect(diff).not_to be_empty
+    end
+
+    it 'should return false if the diff value is not empty' do
+      expect(diff_without_value_was).not_to be_empty
+    end
+
+    it 'should return true if the diff was not changed and is empty' do
+      expect(diff_with_empty_values).to be_empty
+    end
+  end
+
+  describe '#value' do
+    it 'should return the diff value' do
+      expect(diff.value).to eq(value)
+    end
+  end
+
+  describe '#value_was' do
+    it 'should accept value_was' do
+      expect(diff.value_was).to eq(value_was)
+    end
+
+    it 'should set value_was to value if it is not specified' do
+      expect(diff_without_value_was.value_was).to eq(value)
+    end
+  end
+end

data/spec/sub_diff_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../../lib/sub_diff', __FILE__)
+
+RSpec.describe SubDiff do
+  subject { 'this is a simple test' }
+
+  describe '#sub_diff' do
+    context 'with a string' do
+      it 'should process arguments correctly' do
+        result = subject.sub_diff('simple', 'very simple')
+        expect(result.to_s).to eq('this is a very simple test')
+        expect(result.size).to eq(3)
+      end
+
+      it 'should handle no matches correctly' do
+        result = subject.sub_diff('no-match', 'test')
+        expect(result.to_s).to eq(subject)
+        expect(result.size).to eq(0)
+      end
+    end
+
+    context 'with a regex' do
+      it 'should process arguments correctly' do
+        result = subject.sub_diff(/a \S+/, 'an easy')
+        expect(result.to_s).to eq('this is an easy test')
+        expect(result.size).to eq(3)
+      end
+
+      it 'should handle captures correctly' do
+        result = subject.sub_diff(/a (\S+)/, 'a very \1')
+        expect(result.to_s).to eq('this is a very simple test')
+        expect(result.size).to eq(3)
+      end
+    end
+
+    context 'with a block' do
+      it 'should process arguments correctly' do
+        result = subject.sub_diff('simple') { |match| 'block' }
+        expect(result.to_s).to eq('this is a block test')
+        expect(result.size).to eq(3)
+      end
+    end
+
+    if RUBY_VERSION > '1.8.7'
+      context 'with a hash' do
+        it 'should process arguments correctly' do
+          result = subject.sub_diff(/simple/, 'simple' => 'harder')
+          expect(result.to_s).to eq('this is a harder test')
+          expect(result.size).to eq(3)
+        end
+      end
+    end
+  end
+
+  describe '#gsub_diff' do
+    context 'with a string' do
+      it 'should process arguments correctly' do
+        result = subject.gsub_diff('i', 'x')
+        expect(result.to_s).to eq('thxs xs a sxmple test')
+        expect(result.size).to eq(7)
+      end
+
+      it 'should handle no matches correctly' do
+        result = subject.gsub_diff('no-match', 'test')
+        expect(result.to_s).to eq(subject)
+        expect(result.size).to eq(0)
+      end
+    end
+
+    context 'with a regex' do
+      it 'should process arguments correctly' do
+        result = subject.gsub_diff(/(\S*is)/, 'X')
+        expect(result.to_s).to eq('X X a simple test')
+        expect(result.size).to eq(4)
+      end
+
+      it 'should handle captures correctly' do
+        result = subject.gsub_diff(/(\S*is)/, 'X(\1)')
+        expect(result.to_s).to eq('X(this) X(is) a simple test')
+        expect(result.size).to eq(4)
+      end
+    end
+
+    context 'with a block' do
+      it 'should process arguments correctly' do
+        result = subject.gsub_diff('i') { |match| 'x' }
+        expect(result.to_s).to eq('thxs xs a sxmple test')
+        expect(result.size).to eq(7)
+      end
+    end
+
+    if RUBY_VERSION > '1.8.7'
+      context 'with a hash' do
+        it 'should process arguments correctly' do
+          result = subject.gsub_diff(/(\S*is)/, 'is' => 'IS', 'this' => 'THIS')
+          expect(result.to_s).to eq('THIS IS a simple test')
+          expect(result.size).to eq(4)
+        end
+      end
+    end
+  end
+end

data/sub_diff.gemspec

@@ -0,0 +1,18 @@
+require File.expand_path('../lib/sub_diff/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.author           = 'Sean Huber'
+  s.email            = 'github@shuber.io'
+  s.extra_rdoc_files = %w(LICENSE)
+  s.files            = `git ls-files`.split("\n")
+  s.homepage         = 'https://github.com/shuber/sub_diff'
+  s.license          = 'MIT'
+  s.name             = 'sub_diff'
+  s.rdoc_options     = %w(--charset=UTF-8 --inline-source --line-numbers --main README.md)
+  s.require_paths    = %w(lib)
+  s.summary          = 'Inspect the changes of your `String#sub` and `String#gsub` replacements'
+  s.test_files       = `git ls-files -- spec/*`.split("\n")
+  s.version          = SubDiff::VERSION
+
+  s.add_development_dependency 'rspec'
+end

metadata

@@ -1,94 +1,88 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: sub_diff
-version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 0
-  version: 0.0.0
+version: !ruby/object:Gem::Version
+  version: 1.0.0
 platform: ruby
-authors: 
+authors:
 - Sean Huber
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-16 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: respond_to_missing
+date: 2015-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id001
-description: Allows you to apply regular expression replacements to strings while presenting the result in a "diff" like format
-email: shuber@huberry.com
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: github@shuber.io
 executables: []
-
 extensions: []
-
-extra_rdoc_files: []
-
-files: 
+extra_rdoc_files:
+- LICENSE
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/sub_diff.rb
+- lib/sub_diff/core_ext/string.rb
 - lib/sub_diff/diff.rb
+- lib/sub_diff/diff_builder.rb
 - lib/sub_diff/diff_collection.rb
+- lib/sub_diff/differ.rb
+- lib/sub_diff/gsub.rb
+- lib/sub_diff/sub.rb
 - lib/sub_diff/version.rb
-- lib/sub_diff.rb
-- Gemfile
-- MIT-LICENSE
-- Rakefile
-- README.rdoc
-- test/diff_collection_test.rb
-- test/diff_test.rb
-- test/sub_diff_test.rb
-- test/test_helper.rb
-has_rdoc: true
-homepage: http://github.com/shuber/sub_diff
-licenses: []
-
+- spec/spec_helper.rb
+- spec/sub_diff/diff_collection_spec.rb
+- spec/sub_diff/diff_spec.rb
+- spec/sub_diff_spec.rb
+- sub_diff.gemspec
+homepage: https://github.com/shuber/sub_diff
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
-rdoc_options: []
-
-require_paths: 
+rdoc_options:
+- "--charset=UTF-8"
+- "--inline-source"
+- "--line-numbers"
+- "--main"
+- README.md
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
-summary: Apply regular expression replacements to strings while presenting the result in a "diff" like format
-test_files: 
-- test/diff_collection_test.rb
-- test/diff_test.rb
-- test/sub_diff_test.rb
-- test/test_helper.rb
+specification_version: 4
+summary: Inspect the changes of your `String#sub` and `String#gsub` replacements
+test_files:
+- spec/spec_helper.rb
+- spec/sub_diff/diff_collection_spec.rb
+- spec/sub_diff/diff_spec.rb
+- spec/sub_diff_spec.rb

data/README.rdoc

@@ -1,32 +0,0 @@
-= sub_diff
-
-Allows you to apply regular expression replacements to strings while presenting the result in a "diff" like format
-
-== Installation
-
-  gem install sub_diff
-
-
-== Usage
-
-<tt>String#gsub_diff</tt> or <tt>String#sub_diff</tt> accept the same arguments as the standard <tt>gsub</tt> and <tt>sub</tt> methods, however the returned object is enumerable and allows you to iterate thru each replacement
-
-  replacement = 'this is a test'.gsub_diff(/(\S*is)/, 'x(\1)')
-  
-  puts replacement
-  # => x(this) x(is) a test
-  
-  replacement.each { |diff| puts [diff.changed?, diff.value_was.inspect, diff.value.inspect].join(' - ') }
-  # => true - "this" - "x(this)"
-  # => false - " " - " "
-  # => true - "is" - "x(is)"
-  # => false - " a test" - " a test"
-
-
-== Patches and pull requests
-
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a future version unintentionally.
-* Commit, do not mess with Rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.

data/Rakefile

@@ -1,22 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rdoc/task'
-
-desc 'Default: run unit tests'
-task :default => :test
-
-desc 'Test the sub_diff gem'
-Rake::TestTask.new(:test) do |t|
-  t.libs += ['lib', 'test']
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the sub_diff gem'
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'sub_diff'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/test/diff_collection_test.rb

@@ -1,42 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module SubDiff
-  class DiffCollectionTest < Test::Unit::TestCase
-    def setup
-      @diffs = [Diff.new('one '), Diff.new('two', '2'), Diff.new(' three ')]
-      @diff_collection = DiffCollection.new(@diffs)
-    end
-
-    def test_append
-      size, value = @diff_collection.size, @diff_collection.to_s
-      @diff_collection << Diff.new('four', '4')
-      @diff_collection << Diff.new('', 'test')
-      @diff_collection << Diff.new('') # should skip this since it's empty
-      assert_equal size + 2, @diff_collection.size
-      assert_not_equal value, @diff_collection.to_s
-    end
-
-    def test_enumerable
-      assert @diff_collection.is_a?(Enumerable)
-      assert_equal @diffs, @diff_collection.collect { |diff| diff }
-    end
-
-    def test_method_missing
-      assert_equal @diffs.to_s.upcase, @diff_collection.upcase
-      assert_raises(NoMethodError) { @diff_collection.invalid_method }
-    end
-
-    def test_respond_to_missing?
-      assert @diff_collection.respond_to?(:upcase)
-      assert !@diff_collection.respond_to?(:invalid_method)
-    end
-
-    def test_size
-      assert_equal @diffs.size, @diff_collection.size
-    end
-
-    def to_s
-      assert_equal @diffs.join, @diff_collection.to_s
-    end
-  end
-end

data/test/diff_test.rb

@@ -1,42 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module SubDiff
-  class DiffTest < Test::Unit::TestCase
-    def setup
-      @diff_value = 'test'
-      @diff_value_was = 'testing'
-      @diff = Diff.new(@diff_value, @diff_value_was)
-      @diff_without_value_was = Diff.new(@diff_value)
-    end
-
-    def test_initialize_with_value_was
-      assert_equal @diff_value, @diff.value
-      assert_equal @diff_value_was, @diff.value_was
-    end
-
-    def test_initialize_without_value_was
-      assert_equal @diff_value, @diff_without_value_was.value
-      assert_equal @diff_without_value_was.value, @diff_without_value_was.value_was
-    end
-
-    def test_changed?
-      assert @diff.changed?
-      assert !@diff_without_value_was.changed?
-      assert !Diff.new('test', 'test').changed?
-    end
-
-    def test_method_missing
-      assert_equal @diff_value.upcase, @diff.upcase
-      assert_raises(NoMethodError) { @diff.invalid_method }
-    end
-
-    def test_respond_to_missing?
-      assert @diff.respond_to?(:upcase)
-      assert !@diff.respond_to?(:invalid_method)
-    end
-
-    def test_to_s
-      assert_equal @diff.value, @diff.to_s
-    end
-  end
-end

data/test/sub_diff_test.rb

@@ -1,85 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module SubDiff
-  class SubDiffTest < Test::Unit::TestCase
-    def setup
-      @string = 'this is a simple test'
-    end
-
-    def test_gsub_diff_with_block
-      diff_collection = @string.gsub_diff('i') { |match| 'x' }
-      assert_equal 'thxs xs a sxmple test', diff_collection.to_s
-      assert_equal 7, diff_collection.size
-    end
-
-    def test_gsub_diff_with_hash
-      diff_collection = @string.gsub_diff(/(\S*is)/, 'is' => 'IS', 'this' => 'THIS')
-      assert_equal 'THIS IS a harder test', diff_collection.to_s
-      assert_equal 4, diff_collection.size
-    rescue TypeError => error # Hash arguments only work in ruby 1.9+
-      assert_equal "can't convert Hash into String", error.message
-    end
-
-    def test_gsub_diff_with_regex
-      diff_collection = @string.gsub_diff(/(\S*is)/, 'X')
-      assert_equal 'X X a simple test', diff_collection.to_s
-      assert_equal 4, diff_collection.size
-    end
-
-    def test_gsub_diff_with_regex_captures
-      diff_collection = @string.gsub_diff(/(\S*is)/, 'X(\1)')
-      assert_equal 'X(this) X(is) a simple test', diff_collection.to_s
-      assert_equal 4, diff_collection.size
-    end
-
-    def test_gsub_diff_with_string
-      diff_collection = @string.gsub_diff('i', 'x')
-      assert_equal 'thxs xs a sxmple test', diff_collection.to_s
-      assert_equal 7, diff_collection.size
-    end
-
-    def test_gsub_diff_without_matches
-      diff_collection = @string.gsub_diff('no-match', 'test')
-      assert_equal @string, diff_collection.to_s
-      assert_equal 1, diff_collection.size
-    end
-
-    def test_sub_diff_with_block
-      diff_collection = @string.sub_diff('simple') { |match| 'block' }
-      assert_equal 'this is a block test', diff_collection.to_s
-      assert_equal 3, diff_collection.size
-    end
-
-    def test_sub_diff_with_hash
-      diff_collection = @string.sub_diff(/simple/, 'simple' => 'harder')
-      assert_equal 'this is a harder test', diff_collection.to_s
-      assert_equal 3, diff_collection.size
-    rescue TypeError => error # Hash arguments only work in ruby 1.9+
-      assert_equal "can't convert Hash into String", error.message
-    end
-
-    def test_sub_diff_with_regex
-      diff_collection = @string.sub_diff(/a \S+/, 'an easy')
-      assert_equal 'this is an easy test', diff_collection.to_s
-      assert_equal 3, diff_collection.size
-    end
-
-    def test_sub_diff_with_regex_captures
-      diff_collection = @string.sub_diff(/a (\S+)/, 'a very \1')
-      assert_equal 'this is a very simple test', diff_collection.to_s
-      assert_equal 3, diff_collection.size
-    end
-
-    def test_sub_diff_with_string
-      diff_collection = @string.sub_diff('simple', 'very simple')
-      assert_equal 'this is a very simple test', diff_collection.to_s
-      assert_equal 3, diff_collection.size
-    end
-
-    def test_sub_diff_without_matches
-      diff_collection = @string.sub_diff('no-match', 'test')
-      assert_equal @string, diff_collection.to_s
-      assert_equal 1, diff_collection.size
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,7 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'test/unit'
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$:.unshift(File.dirname(__FILE__))
-require 'sub_diff'