invoca-utils 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60e1c062370766eca1fa617f36be49862eaf88ac
+  data.tar.gz: e459f4db3a562dd66d965f781471931b69721f22
+SHA512:
+  metadata.gz: 13f0207b9e47f0197970d027c6ce5956a8513f9cc4d6771a880470d57ef0bc0f54cc851b3220d683b98025790d49ff2f05c21a19c34e1ce4887073c10f83ea0f
+  data.tar.gz: 917afbc8c609b0361cc3a5e1c373c7164de6b2350c6f2209ca3ede0288393c9c3b8d4e02e50625b85bd89973302e15fe0559f570af9cd4846d8c907c94126bcd

data/.gitignore

@@ -0,0 +1,23 @@
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in invoca-utils.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Invoca, Inc.
+
+MIT License
+
+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,25 @@
+# Invoca::Utils
+
+A public collection of helpers used in multiple project.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'invoca-utils'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install invoca-utils
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/invoca-utils/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+namespace :test do
+
+  Rake::TestTask.new do |t|
+    t.name = :unit
+    t.libs << "test"
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:unit'].comment = "Run the unit tests"
+
+end
+
+task :default => 'test:unit'
+

data/invoca-utils.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'invoca/utils/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "invoca-utils"
+  spec.version       = Invoca::Utils::VERSION
+  spec.authors       = ["Cary Penniman"]
+  spec.email         = ["cpenniman@invoca.com"]
+  spec.summary       = %q{A public collection of helpers used in multiple projects}
+  spec.description   = %q{A public collection of helpers used in multiple projects}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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"
+end

data/lib/invoca/utils/diff.rb

@@ -0,0 +1,377 @@
+# 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
+
+    # 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)
+        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
+
+  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.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,index| "- #{format t}\n#{ nested_compare( del, add, index ) }"}.join +
+                  add.map_with_index { |t,index| "+ #{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 = "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
+    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]
+          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
+        end
+        curdiff.push [action, offset, s]
+      end
+      diffs.push curdiff
+    end
+    @diffs = diffs
+    self
+  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]
+        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
+
+  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 discardb(i, elem)
+    @curdiffs.push ['+', i, elem]
+  end
+
+  def inspect
+    @diffs.inspect
+  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.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
+      bi += 1
+    end
+    return newary
+  end
+end
+
+module Diffable
+  def diff(b)
+    Diff.new(self, b)
+  end
+end
+
+#
+#class Array
+#  include Diffable
+#end
+#
+#class String
+#  include Diffable
+#end
+
+=begin
+= Diff
+(({diff.rb})) - computes the differences between two arrays or
+strings. Copyright (C) 2001 Lars Christensen
+
+== Synopsis
+
+    diff = Diff.new(a, b)
+    b = a.patch(diff)
+
+== Class Diff
+=== Class Methods
+--- Diff.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/invoca/utils/log_error_stub.rb

@@ -0,0 +1,84 @@
+#
+# Used by functional tests to track exceptions.
+#
+
+module LogErrorStub
+  class UnexpectedExceptionLogged < StandardError; end
+  class ExpectedExceptionNotLogged < StandardError; end
+
+  def setup_log_error_stub
+    clear_exception_whitelist
+    stub_log_error unless respond_to?(:dont_stub_log_error) && dont_stub_log_error
+  end
+
+  def teardown_log_error_stub
+    ExceptionHandling.stub_handler = nil
+    return unless @exception_whitelist
+    @exception_whitelist.each do |item|
+      add_failure("log_error expected #{item[1][:expected]} times with pattern: '#{item[0].is_a?(Regexp) ? item[0].source : item[0]}' #{item[1][:count]} found #{item[1][:found]}") unless item[1][:expected] == item[1][:found]
+    end
+  end
+
+  attr_accessor :exception_whitelist
+
+  #
+  # Call this function in your functional tests - usually first line after a "should" statement
+  # once called, you can then call expects_exception
+  # By stubbing log error, ExceptionHandling will keep a list of all expected exceptions and
+  # gracefully note their occurrence.
+  #
+  def stub_log_error
+    ExceptionHandling.stub_handler = self
+  end
+
+  #
+  # Gets called by ExceptionHandling::log_error in test mode.
+  # If you have called expects_exception then this function will simply note that an
+  # instance of that exception has occurred - otherwise it will raise (which will
+  # generally result in a 500 return code for your test request)
+  #
+  def handle_stub_log_error(exception_data, always_raise = false)
+    raise_unexpected_exception(exception_data) if always_raise || !exception_filtered?(exception_data)
+  end
+
+  #
+  # Did the calling code call expects_exception on this exception?
+  #
+  def exception_filtered?(exception_data)
+    @exception_whitelist && @exception_whitelist.any? do |expectation|
+      if expectation[0] === exception_data[:error]
+        expectation[1][:found] += 1
+        true
+      end
+    end
+  end
+
+  #
+  # Call this from your test file to declare what exceptions you expect to raise.
+  #
+  def expects_exception(pattern, options = {})
+    @exception_whitelist ||= []
+    expected_count = options[:count] || 1
+    options = {:expected => expected_count, :found => 0}
+    if to_increment = @exception_whitelist.find {|ex| ex[0] == pattern}
+      to_increment[1][:expected] += expected_count
+    else
+      @exception_whitelist << [pattern, options]
+    end
+  end
+
+  def clear_exception_whitelist
+    @exception_whitelist = nil
+  end
+
+  private
+
+  def raise_unexpected_exception(exception_data)
+    raise(UnexpectedExceptionLogged,
+          exception_data[:error] + "\n" +
+          "---original backtrace---\n" +
+          exception_data[:backtrace].join("\n") + "\n" +
+          "------")
+  end
+
+end

data/lib/invoca/utils/version.rb

@@ -0,0 +1,5 @@
+module Invoca
+  module Utils
+    VERSION = "0.0.1"
+  end
+end

data/lib/invoca/utils.rb

@@ -0,0 +1,10 @@
+require "invoca/utils/version"
+
+require "invoca/utils/diff"
+require "invoca/utils/log_error_stub"
+
+module Invoca
+  module Utils
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+require "minitest/autorun"
+require 'rr'
+require 'shoulda'
+require 'pry'

data/test/unit/utils_test.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../test_helper',  __FILE__)
+
+class UtilsTest < Minitest::Test
+  require 'invoca/utils'
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: invoca-utils
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cary Penniman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A public collection of helpers used in multiple projects
+email:
+- cpenniman@invoca.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- invoca-utils.gemspec
+- lib/invoca/utils.rb
+- lib/invoca/utils/diff.rb
+- lib/invoca/utils/log_error_stub.rb
+- lib/invoca/utils/version.rb
+- test/test_helper.rb
+- test/unit/utils_test.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A public collection of helpers used in multiple projects
+test_files:
+- test/test_helper.rb
+- test/unit/utils_test.rb