invoca-utils 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9af5982666a515cac52ec601dcc30bb8be8b473a
-  data.tar.gz: ab9b463b80311d295136c72b5df683b959e03579
+  metadata.gz: 14c0f52c191ceaa28ea84e6c14c7dedcee379d12
+  data.tar.gz: ec9d1132db9c4c9ea067e5797e464d4b194d4d0e
 SHA512:
-  metadata.gz: 0b807a493e7bedc3eca0901d3276723d8cadc91cd3a67a2b31b009695f0be4ffd16562254802a9aab4526b29bd463da17b942400e197a122d08a41e0c37b8c8c
-  data.tar.gz: 4fcf0da07ac921a2410271dd84c94599ca5ee8893be9db532e41970141fdd35172459f843a32c8cabbc2887b13b4d039991059322a43359090565cbf34a603ea
+  metadata.gz: d5cea013efd99a4a8a34593bd95fb601135c0abe96aa53e579b8e6b47a8d3d4f8c34cd6d34a8e635067909835500a160a646c6105f8c658a2827698f83de9b40
+  data.tar.gz: 3a9101e2351ef8081b6199109ed97d5f22d50d306e6762519f68742cd624de3773daeabd5d7d7ecfe5c6260357c0e02a91870b87ab695f96b123d74f3b4c7712

data/.gitignore

@@ -21,3 +21,4 @@ tmp
 *.a
 mkmf.log
 .idea/
+.rubocop-http*

data/.rubocop.yml

@@ -0,0 +1,5 @@
+# This rubocop config file inherits from our centralized style-guide repository.
+# If you are looking to update the ruby style guide, be sure to both update the rubocop config
+# as well as the README.md
+# https://github.com/Invoca/style-guide/tree/master/ruby
+inherit_from: https://raw.githubusercontent.com/Invoca/style-guide/master/ruby/.rubocop.yml

data/Gemfile

@@ -1,5 +1,15 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in invoca-utils.gemspec
 gemspec
 
+group :development do
+  gem 'bundler',   '~> 1.6'
+  gem 'rake'
+  gem 'test-unit', '= 1.2.3'
+  gem 'rr',        '=1.1.2'
+  gem 'shoulda',   '= 3.5.0'
+  gem 'pry'
+  gem 'ruby-prof'
+  gem 'minitest'
+  gem 'tzinfo'
+end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    invoca-utils (0.0.3)
+    invoca-utils (0.0.4)
 
 GEM
   remote: https://rubygems.org/
@@ -53,4 +53,4 @@ DEPENDENCIES
   tzinfo
 
 BUNDLED WITH
-   1.16.0
+   1.17.3

data/invoca-utils.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'invoca/utils/version'
@@ -17,14 +16,4 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "test-unit", "= 1.2.3"
-  spec.add_development_dependency "rr", "=1.1.2"
-  spec.add_development_dependency "shoulda", "= 3.5.0"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "ruby-prof"
-  spec.add_development_dependency "minitest"
-  spec.add_development_dependency "tzinfo"
 end

data/lib/invoca/utils.rb

@@ -11,3 +11,11 @@ module Invoca
   module Utils
   end
 end
+
+unless defined?(Diff)
+  Diff = Invoca::Utils::Diff
+end
+
+unless defined?(Diffable)
+  Diffable = Invoca::Utils::Diffable
+end

data/lib/invoca/utils/diff.rb

@@ -1,332 +1,340 @@
 # adapted from http://users.cybercity.dk/~dsl8950/ruby/diff-0.3.tar.gz
 
-class Diff
-
-  VERSION = 0.3
-
-  def self.lcs(a, b)
-    astart = 0
-    bstart = 0
-    afinish = a.length-1
-    bfinish = b.length-1
-    lcs = []
-
-    # First we prune off any common elements at the beginning
-    while (astart <= afinish && bstart <= afinish && a[astart] == b[bstart])
-      lcs[astart] = bstart
-      astart += 1
-      bstart += 1
-    end
+module Invoca
+  module Utils
+    class Diff
+
+      VERSION = 0.3
+
+      def self.lcs(a, b)
+        astart  = 0
+        bstart  = 0
+        afinish = a.length - 1
+        bfinish = b.length - 1
+        lcs     = []
+
+        # First we prune off any common elements at the beginning
+        while (astart <= afinish && bstart <= afinish && a[astart] == b[bstart])
+          lcs[astart] = bstart
+          astart      += 1
+          bstart      += 1
+        end
 
-    # now the end
-    while (astart <= afinish && bstart <= bfinish && a[afinish] == b[bfinish])
-      lcs[afinish] = bfinish
-      afinish -= 1
-      bfinish -= 1
-    end
+        # now the end
+        while (astart <= afinish && bstart <= bfinish && a[afinish] == b[bfinish])
+          lcs[afinish] = bfinish
+          afinish      -= 1
+          bfinish      -= 1
+        end
 
-    bmatches = reverse_hash(b, 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 = replacenextlarger(thresh, bindex, k)
+        bmatches = reverse_hash(b, 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 = replacenextlarger(thresh, 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
+            lcs[link[1]] = link[2]
+            link         = link[0]
+          end
         end
-        links[k] = [ (k==0) ? nil : links[k-1], aindex, bindex ] if k
-      }
-    }
-
-    if !thresh.empty?
-      link = links[thresh.length-1]
-      while link
-        lcs[link[1]] = link[2]
-        link = link[0]
-      end
-    end
 
-    return lcs
-  end
+        return lcs
+      end
 
-  def self.nested_compare( subtractions, additions, index )
-    subtraction = subtractions[index]
-    addition    = additions[index]
-    if subtraction.is_a?( Array ) && addition.is_a?( Array )
-      return "Nested array diff:\n#{ compare( subtraction, addition ) }\n"
-    elsif subtraction.is_a?( Hash ) && addition.is_a?( Hash )
-      return "Nested hash diff:\n#{ compare( subtraction, addition ) }\n"
-    else
-      ""
-    end
-  end
+      def self.nested_compare(subtractions, additions, index)
+        subtraction = subtractions[index]
+        addition    = additions[index]
+        if subtraction.is_a?(Array) && addition.is_a?(Array)
+          return "Nested array diff:\n#{ compare(subtraction, addition) }\n"
+        elsif subtraction.is_a?(Hash) && addition.is_a?(Hash)
+          return "Nested hash diff:\n#{ compare(subtraction, addition) }\n"
+        else
+          ""
+        end
+      end
 
-  def self.format(value)
-    value.is_a?(Numeric) || value.is_a?(String) ? value : value.inspect
-  end
+      def self.format(value)
+        value.is_a?(Numeric) || value.is_a?(String) ? value : value.inspect
+      end
 
-  def self.compare arg1, arg2, options={}
-    result = ''
-    if arg1 != arg2
-      if arg1.class == arg2.class || (arg1.is_a?(Hash) && arg2.is_a?(Hash)) || (arg1.is_a?(Array) && arg2.is_a?(Array)) # Hash and Array are equivalent when specialized
-        case arg1
-        when Array
-          diff_obj = Diff.new(arg1, arg2)
-          summary = diff_obj.summary
-          curr_diff = nil
-          (arg1 + [nil]).each_with_index do |arg, index|
-            if curr_diff.nil? || index > curr_diff[1].last
-              curr_diff = summary.shift
-            end
-            unless curr_diff && (curr_diff[1].first..curr_diff[1].last) === index
-              result << "  #{format arg}\n" unless arg.nil? || options[:short_description]
-            end
-            if curr_diff && curr_diff[1].first == index
-              verb, _a_range, _b_range, del, add = curr_diff
-              result <<
-                case verb
-                when 'd'
-                  del.map { |t| "- #{format t}\n"}.join
-                when 'a'
-                  add.map { |t| "+ #{format t}\n"}.join +
-                  (arg.nil? ? '' : "  #{format arg}\n")
-                when 'c'
-                  del.map_with_index { |t, del_index| "- #{format t}\n#{nested_compare(del, add, del_index)}" }.join +
-                  add.map { |t| "+ #{format t}\n" }.join
+      def self.compare arg1, arg2, options = {}
+        result = ''
+        if arg1 != arg2
+          if arg1.class == arg2.class || (arg1.is_a?(Hash) && arg2.is_a?(Hash)) || (arg1.is_a?(Array) && arg2.is_a?(Array)) # Hash and Array are equivalent when specialized
+            case arg1
+            when Array
+              diff_obj  = Diff.new(arg1, arg2)
+              summary   = diff_obj.summary
+              curr_diff = nil
+              (arg1 + [nil]).each_with_index do |arg, index|
+                if curr_diff.nil? || index > curr_diff[1].last
+                  curr_diff = summary.shift
                 end
-            end
-          end
-          summary.empty? or raise "Summary left: #{summary.inspect}"
-        when Hash
-          arg1.each do |key, value|
-            if arg2.has_key? key
-              result += "[#{key.inspect}] #{compare value, arg2[key]};\n" if value != arg2[key]
+                unless curr_diff && (curr_diff[1].first..curr_diff[1].last) === index
+                  result << "  #{format arg}\n" unless arg.nil? || options[:short_description]
+                end
+                if curr_diff && curr_diff[1].first == index
+                  verb, _a_range, _b_range, del, add = curr_diff
+                  result <<
+                    case verb
+                    when 'd'
+                      del.map { |t| "- #{format t}\n" }.join
+                    when 'a'
+                      add.map { |t| "+ #{format t}\n" }.join +
+                        (arg.nil? ? '' : "  #{format arg}\n")
+                    when 'c'
+                      del.map_with_index { |t, del_index| "- #{format t}\n#{nested_compare(del, add, del_index)}" }.join +
+                        add.map { |t| "+ #{format t}\n" }.join
+                    end
+                end
+              end
+              summary.empty? or raise "Summary left: #{summary.inspect}"
+            when Hash
+              arg1.each do |key, value|
+                if arg2.has_key? key
+                  result += "[#{key.inspect}] #{compare value, arg2[key]};\n" if value != arg2[key]
+                else
+                  result += "[#{key.inspect}] expected #{value.inspect}, was missing;\n"
+                end
+              end
+              (arg2.keys - arg1.keys).each do |key|
+                result += "[#{key.inspect}] not expected, was #{arg2[key].inspect};\n"
+              end
             else
-              result += "[#{key.inspect}] expected #{value.inspect}, was missing;\n"
+              result = "expected #{arg1.inspect}, was #{arg2.inspect} "
             end
+          elsif arg1.class.in?([Float, BigDecimal]) && arg2.class.in?([Float, BigDecimal])
+            result = "expected #{arg1.class}: #{arg1.to_s}, was #{arg2.class}: #{arg2.to_s} "
+          else
+            result = "expected #{arg1.class}:#{arg1.inspect}, was #{arg2.class}:#{arg2.inspect} "
           end
-          (arg2.keys - arg1.keys).each do |key|
-            result += "[#{key.inspect}] not expected, was #{arg2[key].inspect};\n"
-          end
-        else
-          result = "expected #{arg1.inspect}, was #{arg2.inspect} "
         end
-      elsif arg1.class.in?([Float,BigDecimal]) && arg2.class.in?([Float,BigDecimal])
-        result = "expected #{arg1.class}: #{arg1.to_s}, was #{arg2.class}: #{arg2.to_s} "
-      else
-        result = "expected #{arg1.class}:#{arg1.inspect}, was #{arg2.class}:#{arg2.inspect} "
+        result
       end
-    end
-    result
-  end
 
 
-  def makediff(a, b)
-    lcs = self.class.lcs(a, b)
-    ai = bi = 0
-    while ai < lcs.length
-      if lcs[ai]
-        while bi < lcs[ai]
+      def makediff(a, b)
+        lcs = self.class.lcs(a, b)
+        ai  = bi = 0
+        while ai < lcs.length
+          if lcs[ai]
+            while bi < lcs[ai]
+              discardb(bi, b[bi])
+              bi += 1
+            end
+            match
+            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
-        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
-  end
 
-  def compact!
-    diffs = []
-    @diffs.each do |diff|
-      puts "compacting #{diff.inspect}"
-      i = 0
-      curdiff = []
-      while i < diff.length
-        action = diff[i][0]
-        s = @difftype.is_a?(String) ? diff[i][2,1] : [diff[i][2]]
-        offset = diff[i][1]
-        last = offset
-        i += 1
-        while diff[i] && diff[i][0] == action && diff[i][1] == last+1
-          s << diff[i][2]
-          last = diff[i][1]
-          i += 1
+      def compact!
+        diffs = []
+        @diffs.each do |diff|
+          puts "compacting #{diff.inspect}"
+          i       = 0
+          curdiff = []
+          while i < diff.length
+            action = diff[i][0]
+            s      = @difftype.is_a?(String) ? diff[i][2, 1] : [diff[i][2]]
+            offset = diff[i][1]
+            last   = offset
+            i      += 1
+            while diff[i] && diff[i][0] == action && diff[i][1] == last + 1
+              s << diff[i][2]
+              last = diff[i][1]
+              i    += 1
+            end
+            curdiff.push [action, offset, s]
+          end
+          diffs.push curdiff
         end
-        curdiff.push [action, offset, s]
+        @diffs = diffs
+        self
       end
-      diffs.push curdiff
-    end
-    @diffs = diffs
-    self
-  end
 
-  def compact
-    result = self.dup
-    result.compact!
-    result
-  end
+      def compact
+        result = self.dup
+        result.compact!
+        result
+      end
 
-  def summary
-    result = []
-    b_offset = 0
-    @diffs.each do |block|
-      del = []
-      add = []
-      block.each do |diff|
-        case diff[0]
-        when "-"
-          del << diff[2]
-        when "+"
-          add << diff[2]
+      def summary
+        result   = []
+        b_offset = 0
+        @diffs.each do |block|
+          del = []
+          add = []
+          block.each do |diff|
+            case diff[0]
+            when "-"
+              del << diff[2]
+            when "+"
+              add << diff[2]
+            end
+          end
+          first                  = block[0][1]
+          verb, a_range, b_range =
+            if del.empty?
+              ['a', [first - b_offset, first - b_offset], [first, first + add.size - 1]]
+            elsif add.empty?
+              ['d', [first, first + del.size - 1], [first + b_offset, first + b_offset]]
+            else
+              ['c', [first, first + del.size - 1], [first + b_offset, first + b_offset + add.size - 1]]
+            end
+          b_offset               = b_offset + add.size - del.size
+          result << [verb, a_range, b_range, del, add]
         end
+        result
       end
-      first = block[0][1]
-      verb, a_range, b_range =
-        if del.empty?
-          [ 'a', [first-b_offset,first-b_offset], [first, first+add.size-1] ]
-        elsif add.empty?
-          [ 'd', [first, first+del.size-1],       [first+b_offset, first+b_offset] ]
-        else
-          [ 'c', [first, first+del.size-1],       [first+b_offset, first+b_offset+add.size-1] ]
-        end
-        b_offset = b_offset + add.size - del.size
-      result << [verb, a_range, b_range, del, add]
-    end
-    result
-  end
 
-  attr_reader :diffs, :difftype
+      attr_reader :diffs, :difftype
 
-  def initialize(a, b)
-    @difftype = a.class
-    @diffs = []
-    @curdiffs = []
-    makediff(a, b)
-  end
-
-  def match
-    @diffs << @curdiffs unless @curdiffs.empty?
-    @curdiffs = []
-  end
-
-  def discarda(i, elem)
-    @curdiffs.push ['-', i, elem]
-  end
+      def initialize(a, b)
+        @difftype = a.class
+        @diffs    = []
+        @curdiffs = []
+        makediff(a, b)
+      end
 
-  def discardb(i, elem)
-    @curdiffs.push ['+', i, elem]
-  end
+      def match
+        @diffs << @curdiffs unless @curdiffs.empty?
+        @curdiffs = []
+      end
 
-  def inspect
-    @diffs.inspect
-  end
+      def discarda(i, elem)
+        @curdiffs.push ['-', i, elem]
+      end
 
-  # Create a hash that maps elements of the array to arrays of indices
-  # where the elements are found.
-
-  def self.reverse_hash(lhs, range = nil)
-    range ||= (0...lhs.length)
-    revmap = {}
-    range.each { |i|
-      elem = lhs[i]
-      if revmap.has_key? elem
-        revmap[elem].push i
-      else
-        revmap[elem] = [i]
+      def discardb(i, elem)
+        @curdiffs.push ['+', i, elem]
       end
-    }
-    return revmap
-  end
 
-  def self.replacenextlarger(lhs, value, high = nil)
-    high ||= lhs.length
-    if lhs.empty? || value > lhs[-1]
-      lhs.push value
-      return high
-    end
-    # binary search for replacement point
-    low = 0
-    while low < high
-      index = (high+low)/2
-      found = lhs[index]
-      return nil if value == found
-      if value > found
-        low = index + 1
-      else
-        high = index
+      def inspect
+        @diffs.inspect
       end
-    end
 
-    lhs[low] = value
-    # $stderr << "replace #{value} : 0/#{low}/#{init_high} (#{steps} steps) (#{init_high-low} off )\n"
-    # $stderr.puts lhs.inspect
-    #gets
-    #p length - low
-    return low
-  end
+      # Create a hash that maps elements of the array to arrays of indices
+      # where the elements are found.
+
+      def self.reverse_hash(lhs, range = nil)
+        range  ||= (0...lhs.length)
+        revmap = {}
+        range.each { |i|
+          elem = lhs[i]
+          if revmap.has_key? elem
+            revmap[elem].push i
+          else
+            revmap[elem] = [i]
+          end
+        }
+        return revmap
+      end
 
-  def self.patch(lhs, 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 << lhs[ai]
-            ai += 1
-            bi += 1
+      def self.replacenextlarger(lhs, value, high = nil)
+        high ||= lhs.length
+        if lhs.empty? || value > lhs[-1]
+          lhs.push value
+          return high
+        end
+        # binary search for replacement point
+        low = 0
+        while low < high
+          index = (high + low) / 2
+          found = lhs[index]
+          return nil if value == found
+          if value > found
+            low = index + 1
+          else
+            high = index
           end
+        end
+
+        lhs[low] = value
+        # $stderr << "replace #{value} : 0/#{low}/#{init_high} (#{steps} steps) (#{init_high-low} off )\n"
+        # $stderr.puts lhs.inspect
+        #gets
+        #p length - low
+        return low
+      end
+
+      def self.patch(lhs, 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 << lhs[ai]
+                ai += 1
+                bi += 1
+              end
+              ai += 1
+            when '+'
+              while bi < mod[1]
+                newary << lhs[ai]
+                ai += 1
+                bi += 1
+              end
+              newary << mod[2]
+              bi += 1
+            else
+              raise "Unknown diff action"
+            end
+          }
+        }
+        while ai < lhs.length
+          newary << lhs[ai]
           ai += 1
-        when '+'
-          while bi < mod[1]
-            newary << lhs[ai]
-            ai += 1
-            bi += 1
-          end
-          newary << mod[2]
           bi += 1
-        else
-          raise "Unknown diff action"
         end
-      }
-    }
-    while ai < lhs.length
-      newary << lhs[ai]
-      ai += 1
-      bi += 1
+        return newary
+      end
     end
-    return newary
   end
 end
 
-module Diffable
-  def diff(b)
-    Diff.new(self, b)
+module Invoca
+  module Utils
+    module Diffable
+      def diff(b)
+        Diff.new(self, b)
+      end
+    end
   end
 end