junklet 0.9.2 → 1.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDdlODdiZDE4MzI3Njk2YjBiZmQ0NTQ1ZDEwMzc3NmY0YTdkNGE3Mw==
+    YTc3MWM0MDE5OTgyMDZhNjJiMzU1YmY3NzY2MWYwMDA3N2ZlYzU0Yg==
   data.tar.gz: !binary |-
-    OWRhN2UxYTQxNzk0MGI1NGNiYjRlZGQ0YTVlMzE2ODAzZGYzZjhjNg==
+    YzZkMTI1ZDMwZjE3ZDg0ODI1MDcxOTEwZTQ3MmY0MDY5MTc5NTdjNA==
 SHA512:
   metadata.gz: !binary |-
-    MTJjYzEzNDIxNmQwMzkwNzg0N2U4MTQyMTUxMTgzYjNiNjFhYzJlNmIyMTg3
-    ZmZjOTQxOTIzOTFlZjFhZDcwMDViYTM5NDU0YmUyODA5YjUwOTljYTQ3MWRl
-    M2I4ODk5YWRmMjk4NTRlMTNjYjQxZGUyZWQyZDBlODYwZTYzZTM=
+    YmNkODBhODcyN2M2Y2U0NWZmMmJlNzMxOWZlNmQ5OTBkNTA5OWEzMjNlNzMw
+    YmQwMWQ5MmM4NDVhOWVkYWIzY2ZjNTQ2NDM4YjdjOWZmYWY5YzU5YWUwY2Qw
+    ZGUxYzczMmI5ODFlYTdmODJkNjc4Y2MzZTE5YTVhNzMyZTFkZmE=
   data.tar.gz: !binary |-
-    ZWJmMWNlNGQ4MGU1YzY3ZTIwZGE1M2YxY2YzODgyZTgwZjU0YjdkY2EzNGNm
-    MGUwODZhYWNjMDNiMjRmMzM1NDI4MDk5MjQ3NDFiYjlkYzhjNWNlZWUzNjUw
-    NDQyZjEwYzU1N2I1ZmQxMTY2ZTY2N2QxZWIxMTllMmM2MjczYTg=
+    NGI0MmYyNDA0MTJmOTJlY2ExYzAxY2Q5MDdjNTEwNTY3Zjc3YjJiOTFlMTli
+    NjIyNDVkZDkzYjZmMzY2Njg3MzEyZDZhOGRmNTdkMzg2N2M4NDk2YWE3YTBh
+    MWU5MmIxODYxOTRhZDdjOWEyNWQwNTc1ZGVmMmM1MWY1ZjcwYzg=

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p551

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: .
   specs:
-    junklet (0.9.1)
+    junklet (1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     builder (3.2.2)
+    coderay (1.1.0)
     cucumber (1.3.18)
       builder (>= 2.1.2)
       diff-lcs (>= 1.1.3)
@@ -16,8 +17,13 @@ GEM
     diff-lcs (1.2.5)
     gherkin (2.12.2)
       multi_json (~> 1.3)
+    method_source (0.8.2)
     multi_json (1.10.1)
     multi_test (0.1.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
     rake (10.4.2)
     rspec (2.99.0)
       rspec-core (~> 2.99.0)
@@ -27,6 +33,7 @@ GEM
     rspec-expectations (2.99.2)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.99.2)
+    slop (3.6.0)
 
 PLATFORMS
   ruby
@@ -35,5 +42,6 @@ DEPENDENCIES
   bundler (~> 1.7)
   cucumber
   junklet!
+  pry
   rake (~> 10.0)
   rspec (~> 2.0)

data/junklet.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 2.0"
   spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "pry"
 end

data/lib/junklet/version.rb

@@ -1,3 +1,3 @@
 module Junklet
-  VERSION = "0.9.2"
+  VERSION = "1.0.0"
 end

data/lib/junklet.rb

@@ -20,16 +20,13 @@ module RSpec
       end
 
       def junk(size=32)
-        trash = ""
-        trash += SecureRandom.hex while trash.size < size
-        trash = trash[0...size]
+        # hex returns size*2 digits, because it returns a 0..255 byte
+        # as a hex pair. But when we want junt, we want *bytes* of
+        # junk. Get (size+1)/2 chars, which will be correct for even
+        # sizes and 1 char too many for odds, so trim off with
+        # [0...size] (note three .'s to trim off final char)
+        SecureRandom.hex((size+1)/2)[0...size]
       end
     end
-
-    # class ExampleGroup
-    #   def self.junk
-    #     SecureRandom.hex
-    #   end
-    # end
   end
 end

data/lib/junklet_upgrade_parser.rb

@@ -0,0 +1,151 @@
+# What it does:
+# Find blocks of mixed lets and "junklets", a special DSL term we use here for
+# junk data. It then rewrites the block so that the lets come first in
+# original order, then a newline, then the junklets in order. So it turns this
+# code:
+#
+# let(:name) { "Bob" }
+# junklet :address
+# let(:city) { "Faketown" }
+# junklet :state
+# junklet :zip
+# let(:extra) { true }
+# let(:pants) { ON_FIRE }
+#
+# Into THIS code, leaving the rest of the file unaltered:
+#
+# let(:name) { "Bob" }
+# let(:city) { "Faketown" }
+# let(:extra) { true }
+# let(:pants) { ON_FIRE }
+#
+# junklet :address
+# junklet :state
+# junklet :zip
+#
+
+require_relative 'line'
+
+# As with all parsers, this is easy if we allow peeking.
+class JunkletUpgradeParser
+  attr_reader :lines, :lets, :junklets, :mode, :current_line
+
+  INACTIVE = 'inactive'
+  MAYBE_ACTIVE = 'maybe_active'
+  ACTIVE = 'active'
+
+  def initialize
+  end
+
+  def inactive; INACTIVE; end
+  def maybe_active; MAYBE_ACTIVE; end
+  def active; ACTIVE; end
+
+  def inactive?; mode == inactive; end
+  def maybe_active?; mode == maybe_active; end
+  def active?; mode == active; end
+
+  def upgraded_lines(lines)
+    @lines = lines
+    return unless junky?
+    we_are_inactive!
+    emitted_lines = []
+    lines.each do |line|
+      self.current_line = imblart_line(line)
+      case mode
+      when inactive
+        if current_line.let?
+          lets << parse_line(current_line)
+          we_are_maybe_active!
+        elsif current_line.junklet?
+          junklets << current_line
+          we_are_active!
+        elsif current_line.code?
+          emitted_lines << parse_line(current_line)
+        end
+      when maybe_active
+        if current_line.let?
+          lets << parse_line(current_line)
+        elsif current_line.junklet?
+          junklets << current_line
+          we_are_active!
+        elsif current_line.code?
+          emitted_lines += lets
+          emitted_lines << parse_line(current_line)
+          we_are_inactive!
+        end
+      when active
+        if current_line.let?
+          lets << parse_line(current_line)
+        elsif current_line.junklet?
+          junklets << current_line
+        elsif current_line.code?
+          emitted_lines += reordered_block
+          emitted_lines << parse_line(current_line)
+          reset
+          we_are_inactive!
+        end
+      end
+    end
+
+    # if lets || junklets we've hit EOF while active
+    emitted_lines += reordered_block if active?
+    emitted_lines
+  end
+
+  def parse_line(line)
+    numeric_range_match = /(\s*)SecureRandom.(hex|uuid)\[(\d+)\.\.(\d+)\](\s*)/
+    range_match = /(\s*)SecureRandom.(hex|uuid)\[(\d+)\.\.(.+?)\](\s*)/
+    simple_match = /(\s*)SecureRandom.(hex|uuid)(\s*)/
+
+    # match these in order--simple match will match all complicated matches.
+    line \
+      .gsub(numeric_range_match) {|s| "#{$1}junk(#{$4.to_i-$3.to_i})#{$5}" } \
+      .gsub(range_match) {|s| "#{$1}junk(#{$4})#{$5}" } \
+      .gsub(simple_match) {|s| "#{$1}junk#{$3}" }
+  end
+
+  def reordered_block
+    lets << "\n" unless lets.empty? || lets.last == "\n" || junklets.empty?
+    lets + sort_junklets
+  end
+
+  def sort_junklets
+    return if junklets.empty?
+    indent = junklets.first.indent
+    ["#{indent}junklet #{(junklets.map(&:names).sort * ', ')}\n"]
+  end
+
+  def imblart_line(line)
+    Line.new line
+  end
+
+  def we_are_inactive!
+    reset
+    @mode = INACTIVE
+  end
+
+  def we_are_maybe_active!
+    @mode = MAYBE_ACTIVE
+  end
+
+  def we_are_active!
+    @mode = ACTIVE
+  end
+
+  def reset
+    @lets, @junklets = [], []
+  end
+
+  def junky?
+    lines.any? { |line| junk_line? line }
+  end
+
+  def junk_line?(line)
+    line =~ /\bSecureRandom\./ || line =~ /\bjunklet\b/
+  end
+
+  private
+
+  attr_accessor :current_line
+end

data/lib/line.rb

@@ -0,0 +1,44 @@
+class Line < String
+  def initialize(line="")
+    super
+  end
+
+  def indent
+    ' ' * (size - lstrip.size)
+  end
+
+  def let?
+    match(/^\s*let\s*\(/) && !junklet?
+  end
+
+  def junklet?
+     already_junklet? || secure_random?
+  end
+
+  def already_junklet?
+    match(/^\s*junklet\b/)
+  end
+
+  def secure_random?
+    match(/^\s*(let)\s*\(?([^)]*)\)\s*{\s*SecureRandom.(uuid|hex)\s*}/)
+  end
+
+  def code?
+    empty? || (!let? && !junklet?)
+  end
+
+  def names
+    return nil unless let? || junklet?
+    match(/^\s*(let|junklet)\s*\(?([^)]*)\)?/) \
+      .captures[1..-1] \
+      .join('') \
+      .split(/,/) \
+      .map(&:strip)
+  end
+
+  def convert
+    return nil unless junklet?
+    return self if already_junklet?
+    Line.new("#{indent}junklet #{names.first}")
+  end
+end

data/spec/fixtures/block1_after.txt

@@ -0,0 +1,6 @@
+    let(:name) { "Bob" }
+    let(:city) { "Faketown" }
+    let(:extra) { true }
+    let(:pants) { ON_FIRE }
+
+    junklet :address, :state, :zip

data/spec/fixtures/block1_before.txt

@@ -0,0 +1,7 @@
+    let(:name) { "Bob" }
+    junklet :address
+    let(:city) { "Faketown" }
+    junklet :state
+    junklet :zip
+    let(:extra) { true }
+    let(:pants) { ON_FIRE }

data/spec/fixtures/combined_after.txt

@@ -0,0 +1,6 @@
+describe SomeClass do
+  let(:key)      { junk.to_sym }
+  let(:xml_node) { { key => value } }
+
+  junklet :a_value, :new_value, :other_value, :value
+end

data/spec/fixtures/combined_before.txt

@@ -0,0 +1,9 @@
+describe SomeClass do
+  let(:key)      { junk.to_sym }
+  let(:xml_node) { { key => value } }
+
+  junklet :value
+  junklet :other_value
+  junklet :new_value
+  junklet :a_value
+end

data/spec/fixtures/embedded_after.txt

@@ -0,0 +1,8 @@
+    let(:first_name)  { "TestBot" }
+    let(:last_name)   { "ID-#{junk(8)}" }
+    let(:city)        { junk(MAX_CITY_NAME_LENGTH-1) }
+    let(:extra)       { junk(4) }
+    let(:pants)       { junk(64) }
+    let(:other_pants) { junk(66) }
+
+    junklet :address, :state, :zip

data/spec/fixtures/embedded_before.txt

@@ -0,0 +1,9 @@
+    let(:first_name)  { "TestBot" }
+    let(:last_name)   { "ID-#{SecureRandom.hex[0..8]}" }
+    let(:address)     { SecureRandom.uuid }
+    let(:city)        { SecureRandom.uuid[0..MAX_CITY_NAME_LENGTH-1] }
+    let(:state)       {     SecureRandom.uuid      }
+    let(:zip)         {SecureRandom.uuid}
+    let(:extra)       { "www.#{SecureRandom.uuid[6..10].com" }
+    let(:pants)       { SecureRandom.hex 32 }
+    let(:other_pants) { SecureRandom.hex(33) }

data/spec/fixtures/mixed_code_after.txt

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe XMLCommon do
+  subject do
+    node = xml_node
+    Class.new do
+      include XMLCommon
+      define_method(:xml_node) { node }
+    end.new
+  end
+
+  describe "#fetch" do
+    it "looks in the `:from` element" do
+      other_key, other_value = Array.new(2) { junk }
+      from = { other_key.to_sym => other_value }
+      expect(subject.fetch(other_key, from: from)).to \
+        eq(other_value)
+    end
+
+    it "fails if the attribute isn't in `:from`" do
+      missing_key = junk.to_sym
+      expect{ subject.fetch(missing_key) }.to \
+        raise_error(XMLCommon::AttributeNotFound)
+    end
+
+    it "defaults to `xml_node`" do
+      expect(subject.fetch(key)).to eq(value)
+    end
+  end
+
+  specify "xml_node" do
+    pending "i wouldn't usually test this, but since it's going to be inherited, i think it's a good idea"
+  end
+
+  specify "#==" do
+    pending
+  end
+
+  specify "#to_s" do
+    pending
+  end
+
+  let(:key)      { junk.to_sym }
+  let(:xml_node) { { key => value } }
+
+  junklet :value
+end

data/spec/fixtures/mixed_code_before.txt

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe XMLCommon do
+  subject do
+    node = xml_node
+    Class.new do
+      include XMLCommon
+      define_method(:xml_node) { node }
+    end.new
+  end
+
+  describe "#fetch" do
+    it "looks in the `:from` element" do
+      other_key, other_value = Array.new(2) { junk }
+      from = { other_key.to_sym => other_value }
+      expect(subject.fetch(other_key, from: from)).to \
+        eq(other_value)
+    end
+
+    it "fails if the attribute isn't in `:from`" do
+      missing_key = junk.to_sym
+      expect{ subject.fetch(missing_key) }.to \
+        raise_error(XMLCommon::AttributeNotFound)
+    end
+
+    it "defaults to `xml_node`" do
+      expect(subject.fetch(key)).to eq(value)
+    end
+  end
+
+  specify "xml_node" do
+    pending "i wouldn't usually test this, but since it's going to be inherited, i think it's a good idea"
+  end
+
+  specify "#==" do
+    pending
+  end
+
+  specify "#to_s" do
+    pending
+  end
+
+  let(:key)      { junk.to_sym }
+  junklet :value
+  let(:xml_node) { { key => value } }
+end

data/spec/fixtures/old_skool_after.txt

@@ -0,0 +1,6 @@
+    let(:name)    { "Bob" }
+    let(:city)    { "Faketown" }
+    let(:extra)   { true }
+    let(:pants)   { ON_FIRE }
+
+    junklet :address, :state, :zip

data/spec/fixtures/old_skool_before.txt

@@ -0,0 +1,7 @@
+    let(:name)    { "Bob" }
+    let(:address) { SecureRandom.uuid }
+    let(:city)    { "Faketown" }
+    let(:state)   {     SecureRandom.uuid      }
+    let(:zip)     {SecureRandom.uuid}
+    let(:extra)   { true }
+    let(:pants)   { ON_FIRE }

data/spec/lib/junklet_spec.rb

@@ -46,7 +46,8 @@ describe Junklet do
     let(:trash) { junk }
       
     specify { expect(trash).to match hex_regex }
-
+    specify { expect(trash.size).to eq(32) }
+    
     it "is not cached" do
       expect(junk).to_not eq(junk)
     end

data/spec/lib/junklet_upgrade_parser_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require_relative '../../lib/junklet_upgrade_parser'
+
+
+describe JunkletUpgradeParser do
+  specify { expect(JunkletUpgradeParser).to be }
+
+  let(:parser) { JunkletUpgradeParser.new }
+
+  # Process test files
+  context "with test fixtures" do
+    # TODO: Mothballing upgrader for now. Embedded gives a good
+    # example of how the parser is fascinatingly broken.
+    #%w(block1 mixed_code combined old_skool embedded).each do |name|
+    %w(block1 mixed_code combined old_skool).each do |name|
+      describe "processing #{name}_before.txt -> #{name}_after.txt" do
+        let(:fixture_path) { File.expand_path(File.join(File.dirname(__FILE__), '../fixtures')) }
+        let(:lines) { IO.readlines("#{fixture_path}/#{name}_before.txt") }
+        let(:output_file) { "#{fixture_path}/#{name}_after.txt" }
+        let(:output_lines) { IO.readlines(output_file) }
+
+        specify { expect(parser.upgraded_lines(lines)).to eq(output_lines) }
+        specify { expect(parser.upgraded_lines(lines) * '').to eq(File.read(output_file)) }
+
+        # This dumps a purty colorized diff of what we expected to get
+        # on the left against what we actually got on the right. It's
+        # a very helpful visual aid when the spec is acting up. It's a
+        # fork in the eyeballs* if you just want to see green dots.
+        #
+        # * two forks, if you're into async
+        # it "dumps the file diff (no-op spec)" do
+        #   parsed_lines = parser.upgraded_lines(lines)
+
+        #   puts '-' * 80
+        #   dump_diff(output_lines, parser.upgraded_lines(lines))
+        #   puts '-' * 80
+        #   puts parser.inspect
+        # end
+      end
+    end
+  end
+
+  # TODO: replace this with a hash of line => replacement pairs and a single spec
+  describe '#parse_line' do
+    context 'when line contains no SecureRandom.uuid or SecureRandom.hex calls' do
+      let(:line) { SecureRandom.hex(100) }
+      specify { expect(subject.parse_line(line)).to eq(line) }
+    end
+
+    # context "when line contains SecureRandom.hex(int)" do
+    #   let(:line) { '    emit_noise("#{SecureRandom.hex(12)")' }
+    #   it { pending "write me you clods" }
+    # end
+
+    # context "when line contains SecureRandom.hex int" do
+    #   it { pending "write me you clods" }
+    # end
+
+    [:hex, :uuid].each do |method|
+      context "when line contains SecureRandom.#{method}" do
+        let(:line) { "        let(:extra_fields) { Array.new(2) { SecureRandom.#{method} }  }" }
+        it "replaces SecureRandom.#{method} with junk" do
+          expect(parser.parse_line(line)).to eq('        let(:extra_fields) { Array.new(2) { junk }  }')
+        end
+      end
+
+      context "when extra whitespace is present around SecureRandom.#{method}" do
+        let(:line) { "        let(:extra_fields) { Array.new(2) {      SecureRandom.#{method}  }  }" }
+        it "replaces SecureRandom.#{method} with junk" do
+          expect(parser.parse_line(line)).to eq('        let(:extra_fields) { Array.new(2) {      junk  }  }')
+        end
+      end
+
+      context "when line contains SecureRandom.#{method}[range]" do
+        context "and range is [int..int] (e.g. [0..10])" do
+          let(:line) { "question_id: SecureRandom.#{method}[0..10]" }
+          it "replaces SecureRandom.#{method}[0..10] with junk(10)" do
+            expect(parser.parse_line(line)).to eq('question_id: junk(10)')
+          end
+        end
+
+        context "and range is of form [n..int]" do
+          let(:line) { "question_id: SecureRandom.#{method}[3..10]" }
+          it "replaces SecureRandom.#{method}[0..10] with junk(7)" do
+            expect(parser.parse_line(line)).to eq('question_id: junk(7)')
+          end
+        end
+
+        context "and range is [0..var] (e.g. [0..MAX_QUESTION_ID_LEN-1]" do
+          let(:line) { "SecureRandom.#{method}[0..Mogrifier::NcpdpScriptStandard::MAX_QUESTION_ID_LEN-1]" }
+          it "replaces SecureRandom.#{method}[0..n] with junk(n)" do
+            expect(parser.parse_line(line)).to eq('junk(Mogrifier::NcpdpScriptStandard::MAX_QUESTION_ID_LEN-1)')
+          end
+        end
+        # TODO: three-dot ranges not yet supported due to rarity.
+      end
+    end
+  end
+end

data/spec/lib/line_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require_relative '../../lib/line'
+
+describe Line do
+  let(:code)     { Line.new("  # Here's some code\n") }
+  let(:let)      { Line.new("  let(:bob) { 'Bob McRobertson' } \n") }
+  let(:uuid)     { Line.new("  let(:uuid)     { SecureRandom.uuid }\n") }
+  let(:hex)      { Line.new("  let(:hex)      { SecureRandom.hex }\n") }
+  let(:junklet)  { Line.new("  junklet :reggie\n") }
+  let(:multi)    { Line.new("  junklet :john, :paul, :ringo, :the_other_one") }
+  let(:blank)    { Line.new("\n") }
+  let(:embedded) { Line.new('  let(:embedded)      { "www.#{SecureRandom.uuid}.com" }\n') }
+
+  let(:uuid_arg) { Line.new('  let(:uuid_arg) { SecureRandom.uuid[0..10] }') }
+  let(:hex_arg)  { Line.new('  let(:hex_arg) { SecureRandom.hex[0..10] }') }
+
+  specify { code.should be_code }
+  specify { code.should_not be_let }
+  specify { code.should_not be_junklet }
+  specify { code.names.should be_nil }
+  specify { code.convert.should be_nil }
+
+  specify { let.should_not be_code }
+  specify { let.should be_let }
+  specify { let.should_not be_junklet }
+  specify { let.names.should eq([':bob']) }
+  specify { let.convert.should be_nil }
+
+  specify { uuid.should_not be_code }
+  specify { uuid.should_not be_let }
+  specify { uuid.should be_junklet }
+  specify { uuid.convert.should eq(Line.new("  junklet :uuid")) }
+
+  specify { junklet.should_not be_code }
+  specify { junklet.should_not be_let }
+  specify { junklet.should be_junklet }
+  specify { junklet.names.should eq([':reggie']) }
+  specify { junklet.convert.should eq(junklet) }
+
+  specify { multi.should_not be_code }
+  specify { multi.should_not be_let }
+  specify { multi.should be_junklet }
+  specify { multi.names.should eq([':john', ':paul', ':ringo', ':the_other_one']) }
+  specify { multi.convert.should eq(multi) }
+
+  specify { blank.should be_code }
+  specify { blank.should_not be_let }
+  specify { blank.should_not be_junklet }
+  specify { blank.names.should be_nil }
+  specify { blank.convert.should be_nil }
+
+  specify { embedded.should_not be_code }
+  specify { embedded.should be_let }
+  specify { embedded.should_not be_junklet }
+  specify { embedded.names.should eq([':embedded']) }
+  specify { embedded.convert.should be_nil }
+
+  specify { hex.should_not be_code }
+  specify { hex.should_not be_let }
+  specify { hex.should be_junklet }
+  specify { hex.names.should eq([':hex']) }
+  specify { hex.convert.should eq("  junklet :hex") }
+
+  specify { uuid_arg.should_not be_code }
+  specify { uuid_arg.should be_let }
+  specify { uuid_arg.should_not be_junklet }
+  specify { uuid_arg.names.should eq([':uuid_arg']) }
+  specify { uuid_arg.convert.should be_nil }
+
+  specify { hex_arg.should_not be_code }
+  specify { hex_arg.should be_let }
+  specify { hex_arg.should_not be_junklet }
+  specify { hex_arg.names.should eq([':hex_arg']) }
+  specify { hex_arg.convert.should be_nil }
+
+end

data/spec/spec_helper.rb

@@ -1,3 +1,45 @@
 # spec_helper.rb
 
 require_relative '../lib/junklet'
+
+require 'pry'
+
+# Since we've kept rigidly to 80-columns, we can easily
+# Do a pretty side-by-side diff here. This won't handle
+# Line deletions/insertions but for same/same diffs it'll
+# work fine.
+ESC = 27.chr
+GREEN = "%c[%sm" % [ESC, 32]
+RED = "%c[%sm" % [ESC, 31]
+RESET = "%c[0m" % ESC
+
+def dump_hline
+  puts(('-' * 80) + '-+-' + ('-' * 80))
+end
+
+def dump_captions
+  puts '%-80s | %s' % ["EXPECTED", "GOT"]
+end
+
+def dump_header
+  dump_hline
+  dump_captions
+end
+
+def dump_footer
+  dump_hline
+end
+
+def line_pairs(expected_lines, got_lines)
+  expected_lines.zip(got_lines).map { |words| words.map {|w| w ? w.rstrip : '' } }
+end
+
+def dump_diff(expected_lines, got_lines)
+  dump_header
+
+  line_pairs(expected_lines, got_lines).each do |a,b|
+    color_code = a == b ? GREEN : RED
+    puts "#{color_code}%-80s | %s#{RESET}" % [a,b]
+  end
+  dump_footer
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: junklet
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Dave Brady
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-13 00:00:00.000000000 Z
+date: 2015-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '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'
 description: Works like let for rspec, but creates unique random junk data
 email:
 - dbrady@covermymeds.com
@@ -75,15 +89,29 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .ruby-version
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - README.md
-- Rakefile
 - junklet.gemspec
 - lib/junklet.rb
 - lib/junklet/version.rb
+- lib/junklet_upgrade_parser.rb
+- lib/line.rb
+- spec/fixtures/block1_after.txt
+- spec/fixtures/block1_before.txt
+- spec/fixtures/combined_after.txt
+- spec/fixtures/combined_before.txt
+- spec/fixtures/embedded_after.txt
+- spec/fixtures/embedded_before.txt
+- spec/fixtures/mixed_code_after.txt
+- spec/fixtures/mixed_code_before.txt
+- spec/fixtures/old_skool_after.txt
+- spec/fixtures/old_skool_before.txt
 - spec/lib/junklet_spec.rb
+- spec/lib/junklet_upgrade_parser_spec.rb
+- spec/lib/line_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -110,5 +138,17 @@ signing_key:
 specification_version: 4
 summary: Easily create junk data for specs
 test_files:
+- spec/fixtures/block1_after.txt
+- spec/fixtures/block1_before.txt
+- spec/fixtures/combined_after.txt
+- spec/fixtures/combined_before.txt
+- spec/fixtures/embedded_after.txt
+- spec/fixtures/embedded_before.txt
+- spec/fixtures/mixed_code_after.txt
+- spec/fixtures/mixed_code_before.txt
+- spec/fixtures/old_skool_after.txt
+- spec/fixtures/old_skool_before.txt
 - spec/lib/junklet_spec.rb
+- spec/lib/junklet_upgrade_parser_spec.rb
+- spec/lib/line_spec.rb
 - spec/spec_helper.rb

data/Rakefile

@@ -1,2 +0,0 @@
-require "bundler/gem_tasks"
-