midwire_common 1.1.0 → 2.0.0

data/spec/lib/midwire_common/hash_spec.rb

@@ -1,54 +1,58 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe BottomlessHash do
-  subject { described_class.new }
+using MidwireCommon::HashExtensions
+
+RSpec.describe MidwireCommon::BottomlessHash do # rubocop:disable RSpec/MultipleDescribes
+  subject(:bottomless_hash) { described_class.new }
 
   it 'does not raise on missing key' do
     expect do
-      subject[:missing][:key]
-    end.to_not raise_error
+      bottomless_hash[:missing][:key]
+    end.not_to raise_error
   end
 
   it 'returns an empty value on missing key' do
-    expect(subject[:missing][:key]).to be_empty
+    expect(bottomless_hash[:missing][:key]).to be_empty
   end
 
   it 'stores and returns keys' do
-    subject[:existing][:key] = :value
-    expect(subject[:existing][:key]).to eq(:value)
+    bottomless_hash[:existing][:key] = :value
+    expect(bottomless_hash[:existing][:key]).to eq(:value)
   end
 
-  context '#from_hash' do
-    let(:hash) do
-      { existing: { key: { value: :hello } } }
+  describe '#from_hash' do
+    subject(:bottomless_hash) do
+      described_class.from_hash(hash)
     end
 
-    subject do
-      described_class.from_hash(hash)
+    let(:hash) do
+      { existing: { key: { value: :hello } } }
     end
 
     it 'returns old hash values' do
-      expect(subject[:existing][:key][:value]).to eq(:hello)
+      expect(bottomless_hash[:existing][:key][:value]).to eq(:hello)
     end
 
     it 'provides a bottomless version' do
-      expect(subject[:missing][:key]).to be_empty
+      expect(bottomless_hash[:missing][:key]).to be_empty
     end
 
     it 'stores and returns new values' do
-      subject[:existing][:key] = :value
-      expect(subject[:existing][:key]).to eq(:value)
+      bottomless_hash[:existing][:key] = :value
+      expect(bottomless_hash[:existing][:key]).to eq(:value)
     end
 
     it 'converts nested hashes as well' do
       expect do
-        subject[:existing][:key][:missing]
-      end.to_not raise_error
+        bottomless_hash[:existing][:key][:missing]
+      end.not_to raise_error
     end
   end
 end
 
-describe Hash do
+RSpec.describe Hash do
   it 'greps key/value pairs using a regular expression' do
     h = { a: 'this is a test', 'b' => 'this is not the answer' }
     expect(h.grep(/a test/)).to eq([[:a, 'this is a test']])
@@ -58,10 +62,6 @@ describe Hash do
     ).to eq([[:a, 'this is a test'], ['b', 'this is not the answer']])
   end
 
-  it 'returns elements with certain keys filtered out' do
-    expect({ a: 1, b: 2, c: 3 }.except(:a)).to eq(b: 2, c: 3)
-  end
-
   it 'returns elements for discretely passed keys' do
     expect({ a: 1, b: 2, c: 3 }.only(:a)).to eq(a: 1)
   end
@@ -112,7 +112,7 @@ describe Hash do
     let(:h1_values) { { 'a' => 1, 'b' => 2, 'c' => 3 } }
     let(:h2_values) { { 'a' => 1, 'b' => 2, 'c' => 4 } }
 
-    context '.diff' do
+    describe '.diff' do
       it 'reports different keys' do
         expect(h1_keys.diff(h2_keys)).to eq('c' => [3, nil], 'd' => [nil, 3])
       end
@@ -127,5 +127,36 @@ describe Hash do
         )
       end
     end
+
+    describe '.apply_diff!' do
+      it 'applies diff to the right by default' do
+        diff = h1_values.diff(h2_values)
+        result = h1_values.apply_diff!(diff)
+        expect(result).to eq('a' => 1, 'b' => 2, 'c' => 4)
+        expect(h1_values).to eq('a' => 1, 'b' => 2, 'c' => 4)
+      end
+
+      it 'applies diff to the left' do
+        diff = h1_values.diff(h2_values)
+        result = h2_values.apply_diff!(diff, :left)
+        expect(result).to eq('a' => 1, 'b' => 2, 'c' => 3)
+      end
+    end
+
+    describe '.apply_diff' do
+      it 'returns a new hash with diff applied' do
+        diff = h1_values.diff(h2_values)
+        result = h1_values.apply_diff(diff)
+        expect(result).to eq('a' => 1, 'b' => 2, 'c' => 4)
+        expect(h1_values).to eq('a' => 1, 'b' => 2, 'c' => 3)
+      end
+
+      it 'applies diff to the left' do
+        diff = h1_values.diff(h2_values)
+        result = h2_values.apply_diff(diff, :left)
+        expect(result).to eq('a' => 1, 'b' => 2, 'c' => 3)
+        expect(h2_values).to eq('a' => 1, 'b' => 2, 'c' => 4)
+      end
+    end
   end
 end

data/spec/lib/midwire_common/integer_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+using MidwireCommon::IntegerExtensions
+
+RSpec.describe Integer do
+  it 'can format itself with commas' do
+    expect(8_729_928_827.commify).to eq('8,729,928,827')
+  end
+end

data/spec/lib/midwire_common/rake_helper_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module MidwireCommon
   RSpec.describe RakeHelper do
     let(:rake_helper) { described_class.new(Dir.pwd) }
 
-    context '#new' do
+    describe '#new' do
       it 'returns an instance' do
         expect(rake_helper).to be_a(described_class)
       end
@@ -14,7 +16,7 @@ module MidwireCommon
       end
     end
 
-    context '.install' do
+    describe '.install' do
       it 'returns version.rake' do
         file = rake_helper.install.first
         expect(File.basename(file)).to eq('version.rake')
@@ -22,8 +24,9 @@ module MidwireCommon
 
       it 'loads version.rake' do
         file = File.join(MidwireCommon.root, 'lib/tasks/version.rake')
-        expect(rake_helper).to receive(:load).with(file)
+        allow(rake_helper).to receive(:load)
         rake_helper.install
+        expect(rake_helper).to have_received(:load).with(file)
       end
     end
   end

data/spec/lib/midwire_common/string_spec.rb

@@ -1,56 +1,26 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-# rubocop:disable Metrics/LineLength
 require 'spec_helper'
 
+using MidwireCommon::StringExtensions
+
 RSpec.describe String do
   it 'is a String' do
-    ''.should be_a String
+    string = described_class.new
+    expect(string).to be_a described_class
   end
 
   it 'generates a random string' do
-    String.random.length.should == 6
+    expect(described_class.random.length).to eq(6)
   end
 
   context 'slicing methods' do
     it "'left' returns the leftmost 'n' characters" do
-      'My Bogus String'.left(2).should == 'My'
-    end
-
-    it "'right' returns the rightmost 'n' characters " do
-      'My Bogus String'.right(2).should == 'ng'
-    end
-  end
-
-  context 'trim method' do
-    it "'left_trim' removes all whitespace from the left of the string" do
-      " \t = this is a string".left_trim.should == '= this is a string'
-    end
-
-    it "'left_trim!' removes all whitespace from the left of the string" do
-      mystring = " \t \t a test is coming"
-      mystring.left_trim!
-      mystring.should == 'a test is coming'
-    end
-
-    it "'right_trim' removes all whitespace from the right of the string" do
-      "= this is a string \t ".right_trim.should == '= this is a string'
-    end
-
-    it "'right_trim!' removes all whitespace from the right of the string" do
-      mystring = " \t \t a test is coming \t \t "
-      mystring.right_trim!
-      mystring.should == " \t \t a test is coming"
-    end
-
-    it "'trim' removes whitespace from both sides of the string" do
-      " \t \t a test is coming \t \t ".trim.should == 'a test is coming'
+      expect('My Bogus String'.left_substr(2)).to eq('My')
     end
 
-    it "'trim!' removes whitespace from both sides of the string" do
-      mystring = " \t \t a test is coming \t \t "
-      mystring.trim!
-      mystring.should == 'a test is coming'
+    it "'right' returns the rightmost 'n' characters" do
+      expect('My Bogus String'.right_substr(2)).to eq('ng')
     end
   end
 
@@ -61,7 +31,7 @@ RSpec.describe String do
         |<script type="text/javascript">
         |</script>
       STOP
-      html.should == '<!-- Begin: comment  --> <script type="text/javascript"> </script>'
+      expect(html).to eq('<!-- Begin: comment  --> <script type="text/javascript"> </script>')
     end
 
     it 'here_with_pipe - with linefeeds' do
@@ -70,7 +40,7 @@ RSpec.describe String do
         |<script type="text/javascript">
         |</script>
       STOP
-      html.should == "<!-- Begin: comment  -->\n<script type=\"text/javascript\">\n</script>"
+      expect(html).to eq("<!-- Begin: comment  -->\n<script type=\"text/javascript\">\n</script>")
     end
 
     it 'here_with_pipe - with no space delimeter' do
@@ -79,7 +49,7 @@ RSpec.describe String do
         |<script type="text/javascript">
         |</script>
       STOP
-      html.should == '<!-- Begin: comment  --><script type="text/javascript"></script>'
+      expect(html).to eq('<!-- Begin: comment  --><script type="text/javascript"></script>')
     end
 
     it 'format_phone returns a formatted phone number string' do
@@ -95,13 +65,14 @@ RSpec.describe String do
       expect('ßogus'.sanitize).to eq('ogus')
       expect('<tag>bogus</tag>'.sanitize).to eq('tagbogustag')
       expect('<tag>.bogus.</tag>'.sanitize).to eq('tag.bogus.tag')
-      s = '|∫|ß'
+      s = +'|∫|ß'
       s.sanitize!
-      s.should == ''
+      expect(s).to eq('')
     end
 
     it 'shortens itself with elipses at the end' do
-      s = 'this is my very long string which I will eventually shorten with the enhanced String class that we are now testing.'
+      s = 'this is my very long string which I will eventually shorten ' \
+          'with the enhanced String class that we are now testing.'
       short = s.shorten
       expect(short).to eq('this is my very long string...')
       expect(short.length).to eq(30)
@@ -119,58 +90,58 @@ RSpec.describe String do
 
     context 'quotes' do
       it 'escapes single quotes' do
-        "this is a 'test'".escape_single_quotes.should == "this is a \\'test\\'"
+        expect("this is a 'test'".escape_single_quotes).to eq("this is a \\'test\\'")
       end
 
       it 'escapes double quotes' do
         expect('this is a "test"'.escape_double_quotes)
-          .to eq('this is a \\\\"test\\\\"')
+            .to eq('this is a \\\\"test\\\\"')
       end
     end
   end
 
   context 'characterization' do
     it 'knows if it is alpha-numeric or not' do
-      'abcd-9191'.alpha_numeric?.should eq(false)
-      'abcd.9191'.alpha_numeric?.should eq(false)
-      'abcd91910'.alpha_numeric?.should eq(true)
-      'abcd_9191'.alpha_numeric?.should eq(false)
-      'abcd 9191'.alpha_numeric?.should eq(false)
+      expect('abcd-9191'.alpha_numeric?).to be(false)
+      expect('abcd.9191'.alpha_numeric?).to be(false)
+      expect('abcd91910'.alpha_numeric?).to be(true)
+      expect('abcd_9191'.alpha_numeric?).to be(false)
+      expect('abcd 9191'.alpha_numeric?).to be(false)
     end
 
     it 'knows if it is an email address or not' do
-      'abcd_9191'.email_address?.should eq(false)
-      'abcd@9191'.email_address?.should eq(false)
-      'abcd@9191.info'.email_address?.should eq(true)
-      'abcd-asdf@9191.com'.email_address?.should eq(true)
-      'abcd_asdf@9191.com'.email_address?.should eq(true)
-      'abcd.asdf@9191.com'.email_address?.should eq(true)
+      expect('abcd_9191'.email_address?).to be(false)
+      expect('abcd@9191'.email_address?).to be(false)
+      expect('abcd@9191.info'.email_address?).to be(true)
+      expect('abcd-asdf@9191.com'.email_address?).to be(true)
+      expect('abcd_asdf@9191.com'.email_address?).to be(true)
+      expect('abcd.asdf@9191.com'.email_address?).to be(true)
     end
 
     it 'knows if it is a zipcode or not' do
-      '13922-2356'.zipcode?.should eq(true)
-      '13922.2343'.zipcode?.should eq(false)
-      '13922 2342'.zipcode?.should eq(false)
-      'ABSSD'.zipcode?.should eq(false)
-      'i3323'.zipcode?.should eq(false)
-      '13922'.zipcode?.should eq(true)
+      expect('13922-2356'.zipcode?).to be(true)
+      expect('13922.2343'.zipcode?).to be(false)
+      expect('13922 2342'.zipcode?).to be(false)
+      expect('ABSSD'.zipcode?).to be(false)
+      expect('i3323'.zipcode?).to be(false)
+      expect('13922'.zipcode?).to be(true)
     end
 
     it 'knows if it is numeric or not' do
-      '12341'.numeric?.should eq(true)
-      '12341.23'.numeric?.should eq(true)
-      '12341.00000000000000023'.numeric?.should eq(true)
-      '0.12341'.numeric?.should eq(true)
-      '0x2E'.numeric?.should eq(true)
-      ' 0.12341'.numeric?.should eq(true)
-      ' 0.12341 '.numeric?.should eq(true)
-      '.12341'.numeric?.should eq(true)
-      ' 12341.'.numeric?.should eq(false)
-      ' 12341.  '.numeric?.should eq(false)
+      expect('12341'.numeric?).to be(true)
+      expect('12341.23'.numeric?).to be(true)
+      expect('12341.00000000000000023'.numeric?).to be(true)
+      expect('0.12341'.numeric?).to be(true)
+      expect('0x2E'.numeric?).to be(true)
+      expect(' 0.12341'.numeric?).to be(true)
+      expect(' 0.12341 '.numeric?).to be(true)
+      expect('.12341'.numeric?).to be(true)
+      expect(' 12341.'.numeric?).to be(true)
+      expect(' 12341.  '.numeric?).to be(true)
     end
   end
 
-  context '.snakerize' do
+  describe '.snakerize' do
     it 'changes CamelCased string to snake_cased' do
       expect('CamelCased'.snakerize).to eq('camel_cased')
     end
@@ -180,7 +151,7 @@ RSpec.describe String do
     end
   end
 
-  context '.camelize' do
+  describe '.camelize' do
     it 'changes snake cased string to camelized' do
       expect('camel_cased'.camelize).to eq('CamelCased')
     end
@@ -190,4 +161,3 @@ RSpec.describe String do
     end
   end
 end
-# rubocop:enable Metrics/LineLength

data/spec/lib/midwire_common/time_spec.rb

@@ -1,47 +1,46 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Time do
+using MidwireCommon::StringExtensions
+using MidwireCommon::TimeExtensions
+
+RSpec.describe Time do
   context 'generates a timestamp' do
-    it 'appropriate for a filename' do
-      ts = Time.timestamp
+    it 'defaults to nanosecond resolution appropriate for a filename' do
+      ts = described_class.timestamp
       expect(ts.length).to eq(18)
-      expect(ts.numeric?).to eq(true)
+      expect(ts.numeric?).to be(true)
     end
 
     it 'with the only seconds' do
-      ts = Time.timestamp(0)
+      ts = described_class.timestamp(0)
       expect(ts.length).to eq(14)
-      expect(ts.numeric?).to eq(true)
-    end
-
-    it 'defaults to nanosecond resolution' do
-      ts = Time.timestamp
-      expect(ts.length).to eq(18)
-      expect(ts.numeric?).to eq(true)
+      expect(ts.numeric?).to be(true)
     end
 
     it 'with the millisecond resolution' do
-      ts = Time.timestamp(3)
+      ts = described_class.timestamp(3)
       expect(ts.length).to eq(18)
-      expect(ts.numeric?).to eq(true)
+      expect(ts.numeric?).to be(true)
     end
 
     it 'with the microsecond resolution' do
-      ts = Time.timestamp(6)
+      ts = described_class.timestamp(6)
       expect(ts.length).to eq(21)
-      expect(ts.numeric?).to eq(true)
+      expect(ts.numeric?).to be(true)
     end
 
     it 'with the nanosecond resolution' do
-      ts = Time.timestamp(9)
+      ts = described_class.timestamp(9)
       expect(ts.length).to eq(24)
-      expect(ts.numeric?).to eq(true)
+      expect(ts.numeric?).to be(true)
     end
 
     it 'with the picosecond resolution' do
-      ts = Time.timestamp(12)
+      ts = described_class.timestamp(12)
       expect(ts.length).to eq(27)
-      expect(ts.numeric?).to eq(true)
+      expect(ts.numeric?).to be(true)
     end
   end
 end

data/spec/lib/midwire_common/time_tool_spec.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe MidwireCommon::TimeTool do
   it 'converts seconds to timestamp' do
-    MidwireCommon::TimeTool.seconds_to_time(92_353).should == '25:39:13'
+    expect(described_class.seconds_to_time(92_353)).to eq('25:39:13')
   end
 
   it 'converts timestamp to seconds' do
-    MidwireCommon::TimeTool.time_to_seconds('25:39:13').should == 92_353
+    expect(described_class.time_to_seconds('25:39:13')).to eq(92_353)
   end
 end

data/spec/lib/midwire_common/yaml_setting_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe MidwireCommon::YamlSetting do
@@ -7,6 +9,7 @@ describe MidwireCommon::YamlSetting do
   let(:setting) { YamlSetting.new(file) }
 
   before do
+    FileUtils.mkdir_p(tmpdir)
     FileUtils.touch(file)
     setting[:test] = {}
     setting[:test][:a] = 1
@@ -15,13 +18,13 @@ describe MidwireCommon::YamlSetting do
     setting.save
   end
 
-  context '#new' do
+  describe '#new' do
     it 'sets the :file accessor' do
       expect(setting.file).to eq(file)
     end
   end
 
-  context '.load' do
+  describe '.load' do
     it 'returns self' do
       expect(setting.load).to be_a(YamlSetting)
     end
@@ -35,7 +38,7 @@ describe MidwireCommon::YamlSetting do
     end
   end
 
-  context '.save' do
+  describe '.save' do
     it 'stores the current hash' do
       setting[:test] = 'bogus'
       setting.save
@@ -43,13 +46,13 @@ describe MidwireCommon::YamlSetting do
     end
   end
 
-  context '.config' do
+  describe '.config' do
     it 'returns the data hash' do
       expect(setting.config[:test]).to eq(a: 1, b: 2, c: 3)
     end
   end
 
-  context '.data' do
+  describe '.data' do
     it 'returns the data hash' do
       expect(setting.data[:test]).to eq(a: 1, b: 2, c: 3)
     end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if ENV['COVERAGE']
   require 'simplecov'
   SimpleCov.start do
@@ -6,7 +8,7 @@ if ENV['COVERAGE']
   end
 end
 
-require 'pry'
+require 'debug'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'midwire_common')
 require 'midwire_common/all'
 
@@ -15,20 +17,24 @@ PROJECT_ROOT = File.expand_path('..', File.dirname(__FILE__))
 RSpec.configure do |config|
   include MidwireCommon
 
-  config.mock_with :rspec
-  config.color = true
   config.order = 'random'
 
   def capture(stream)
-    begin
-      stream = stream.to_s
-      eval "$#{stream} = StringIO.new"
-      yield
-      result = eval("$#{stream}").string
-    ensure
-      eval("$#{stream} = #{stream.upcase}")
+    stream = stream.to_s
+    captured = StringIO.new
+    original = stream == 'stdout' ? $stdout : $stderr
+    if stream == 'stdout'
+      $stdout = captured
+    else
+      $stderr = captured
+    end
+    yield
+    captured.string
+  ensure
+    if stream == 'stdout'
+      $stdout = original
+    else
+      $stderr = original
     end
-
-    result
   end
 end