nuggets 1.4.0 → 1.6.1

data/lib/nuggets/string/highlight_mixin.rb

@@ -0,0 +1,62 @@
+#--
+###############################################################################
+#                                                                             #
+# nuggets -- Extending Ruby                                                   #
+#                                                                             #
+# Copyright (C) 2007-2016 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# nuggets is free software; you can redistribute it and/or modify it under    #
+# the terms of the GNU Affero General Public License as published by the Free #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# nuggets is distributed in the hope that it will be useful, but WITHOUT ANY  #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with nuggets. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                             #
+###############################################################################
+#++
+
+module Nuggets
+  class String
+    module HighlightMixin
+
+  # call-seq:
+  #   str.highlight(needle[, prefix[, postfix]]) => new_string
+  #
+  # Highlight occurrences of +needle+ (String(s) and/or Regexp(s))
+  # in _str_ by surrounding them with +prefix+ and +postfix+.
+  def highlight(needle, prefix = '|', postfix = prefix)
+    offsets = []
+
+    Array(needle).each { |arg|
+      while index = index(arg, index || 0)
+        offsets << [index, index += ($& || arg).length]
+      end
+    }
+
+    flattened = [current = offsets.sort!.shift]
+
+    offsets.each { |offset|
+      i1, j1 = current
+      i2, j2 = offset
+
+      i2 > j1 ? flattened << current = offset :
+      j2 > j1 ? current[-1] = j2 : nil
+    }
+
+    dup.tap { |result| flattened.reverse_each { |i, j|
+      result.insert(j, postfix).insert(i, prefix)
+    } }
+  end
+
+    end
+  end
+end

data/lib/nuggets/version.rb

@@ -3,8 +3,8 @@ module Nuggets
   module Version
 
     MAJOR = 1
-    MINOR = 4
-    TINY  = 0
+    MINOR = 6
+    TINY  = 1
 
     class << self
 

data/spec/nuggets/array/format_spec.rb

@@ -3,6 +3,7 @@ require 'nuggets/array/format'
 describe Array, 'format' do
 
   def self.test_format(*f)
+    return if RUBY_ENGINE == 'jruby' && JRUBY_VERSION.include?('pre')
     f.pop.each { |x, y| example { (f.dup % x).should == y } }
   end
 
@@ -30,7 +31,7 @@ describe Array, 'format' do
     ['',       '',      ''    ] => ''
   )
 
-  test_format({ :sep => ':' },
+  test_format({ sep: ':' },
     ['1', '2', '3', '4'] => '1:2:3:4',
     ['1', '2', '3', '' ] => '1:2:3',
     ['1', '2', '',  '4'] => '1:2:4',

data/spec/nuggets/enumerable/minmax_spec.rb

@@ -7,7 +7,7 @@ describe Enumerable, 'minmax' do
 
     e.max.should == 'quux'
     e.max_by(:length).should == 'quuux'
-    e.max(:length).should == 5
+    e.max(:length).should == 5 if RUBY_VERSION < '2.4' && RUBY_ENGINE != 'jruby'
   }
 
   example {
@@ -15,7 +15,7 @@ describe Enumerable, 'minmax' do
 
     e.max.should == 222
     e.max_by(b).should == 45
-    e.max(b).should == 5
+    e.max(b).should == 5 if RUBY_VERSION < '2.4' && RUBY_ENGINE != 'jruby'
   }
 
 end

data/spec/nuggets/env/set_spec.rb

@@ -12,12 +12,12 @@ describe_extended ENV, Nuggets::Env::SetMixin, true do
   end
 
   example do
-    ENV.with(:lang => 'C') { ENV['LANG'].should == 'C' }
+    ENV.with(lang: 'C') { ENV['LANG'].should == 'C' }
     ENV['LANG'].should == @original['LANG']
   end
 
   example do
-    ENV.set(:lang => 'C').to_hash.should == @original
+    ENV.set(lang: 'C').to_hash.should == @original
     ENV.to_hash.should == { 'LANG' => 'C' }
   end
 

data/spec/nuggets/env/user_home_spec.rb

@@ -7,36 +7,16 @@ describe_extended ENV, Nuggets::Env::UserHomeMixin, true do
   end
 
   after do
-    ENV.clear
-    ENV.update(@old_env)
+    ENV.clear.update(@old_env)
   end
 
   example do
     ENV.user_home.should be_an_instance_of(String)
   end
 
-  example do
-    ENV.clear
-    ENV.user_home.should be_an_instance_of(String)
-  end
-
   example do
     ENV['HOME'] = 'foo'
     ENV.user_home.should == 'foo'
   end
 
-  unless RUBY_ENGINE == 'jruby'
-
-    example do
-      ENV.clear
-      ENV.user_home('bar').should == 'bar'
-    end
-
-    example do
-      ENV.clear
-      ENV.user_home(nil).should be_nil
-    end
-
-  end
-
 end

data/spec/nuggets/hash/at_spec.rb

@@ -2,7 +2,7 @@ require 'nuggets/hash/at'
 
 describe Hash, 'at' do
 
-  let(:h) { { :a => 1, 2 => 3, nil => nil, 'foo' => %w[b a r] } }
+  let(:h) { { a: 1, 2 => 3, nil => nil, 'foo' => %w[b a r] } }
 
   example { h.first.should == { a: 1 } }
 

data/spec/nuggets/hash/deep_fetch_spec.rb

@@ -54,7 +54,7 @@ describe_extended Hash, Nuggets::Hash::DeepFetchMixin do
 
   context do
 
-    let(:hash) { { :foo => { :bar => { :baz => 42 } } } }
+    let(:hash) { { foo: { bar: { baz: 42 } } } }
 
     example do
       lambda { hash.deep_fetch('foo/bar/baz') }.should raise_error(KeyError)

data/spec/nuggets/hash/deep_merge_spec.rb

@@ -3,58 +3,58 @@ require 'nuggets/hash/deep_merge'
 describe_extended Hash, Nuggets::Hash::DeepMergeMixin do
 
   example do
-    { :a => 1 }.deep_merge(:a => 2).should == { :a => 2 }
+    { a: 1 }.deep_merge(a: 2).should == { a: 2 }
   end
 
   example do
-    { :a => 1 }.deep_merge(:b => 2).should == { :a => 1, :b => 2 }
+    { a: 1 }.deep_merge(b: 2).should == { a: 1, b: 2 }
   end
 
   example do
-    { :a => { :b => 1 } }.deep_merge(:b => 2).should == { :a => { :b => 1 }, :b => 2 }
+    { a: { b: 1 } }.deep_merge(b: 2).should == { a: { b: 1 }, b: 2 }
   end
 
   example do
-    { :a => { :b => 1 } }.deep_merge(:a => { :b => 2 }).should == { :a => { :b => 2 } }
+    { a: { b: 1 } }.deep_merge(a: { b: 2 }).should == { a: { b: 2 } }
   end
 
   example do
-    lambda { { :a => { :b => { :c => 1 } } }.deep_merge(:a => { :b => 2 }) }.should raise_error(TypeError)
+    lambda { { a: { b: { c: 1 } } }.deep_merge(a: { b: 2 }) }.should raise_error(TypeError)
   end
 
   example do
-    { :a => { :b => { :c => 1 } } }.deep_merge(:a => { :b => { :c => 2 } }).should == { :a => { :b => { :c => 2 } } }
+    { a: { b: { c: 1 } } }.deep_merge(a: { b: { c: 2 } }).should == { a: { b: { c: 2 } } }
   end
 
   example do
-    { :a => { :b => { :c => 1 } } }.deep_merge(:a => { :b => { :d => 2 } }).should == { :a => { :b => { :c => 1, :d => 2 } } }
+    { a: { b: { c: 1 } } }.deep_merge(a: { b: { d: 2 } }).should == { a: { b: { c: 1, d: 2 } } }
   end
 
   example do
-    { :a => { :b => { :c => 1 } } }.deep_merge(:a => { :b => { :c => 2 }, :d => 3 }).should == { :a => { :b => { :c => 2 }, :d => 3 } }
+    { a: { b: { c: 1 } } }.deep_merge(a: { b: { c: 2 }, d: 3 }).should == { a: { b: { c: 2 }, d: 3 } }
   end
 
   example do
-    { :a => { :b => { :c => 1 }, :d => 2 } }.deep_merge(:a => { :b => { :c => 2 }, :d => 3 }).should == { :a => { :b => { :c => 2 }, :d => 3 } }
+    { a: { b: { c: 1 }, d: 2 } }.deep_merge(a: { b: { c: 2 }, d: 3 }).should == { a: { b: { c: 2 }, d: 3 } }
   end
 
   example do
-    { :a => { :b => { :c => 1 }, :d => 2 }, :e => 3 }.deep_merge(:a => { :b => { :c => 2 }, :d => 3 }).should == { :a => { :b => { :c => 2 }, :d => 3 }, :e => 3 }
+    { a: { b: { c: 1 }, d: 2 }, e: 3 }.deep_merge(a: { b: { c: 2 }, d: 3 }).should == { a: { b: { c: 2 }, d: 3 }, e: 3 }
   end
 
   example do
-    { :a => { :b => { :c => 1 } }, :d => { :e => 3 } }.deep_merge(:a => { :b => { :c => 2 } }, :d => { :e => 4 }).should == { :a => { :b => { :c => 2 } }, :d => { :e => 4 } }
+    { a: { b: { c: 1 } }, d: { e: 3 } }.deep_merge(a: { b: { c: 2 } }, d: { e: 4 }).should == { a: { b: { c: 2 } }, d: { e: 4 } }
   end
 
   context do
 
     before :each do
-      @sub_hash1 = { :b => 1 }
-      @sub_hash2 = { :b => 2 }
+      @sub_hash1 = { b: 1 }
+      @sub_hash2 = { b: 2 }
 
-      @hash1 = { :a => @sub_hash1 }
-      @hash2 = { :a => @sub_hash2 }
-      @hash3 = { :a => { :b => 2} }
+      @hash1 = { a: @sub_hash1 }
+      @hash2 = { a: @sub_hash2 }
+      @hash3 = { a: { b: 2} }
     end
 
     example do

data/spec/nuggets/hash/seen_spec.rb

@@ -25,7 +25,7 @@ describe_extended Hash, Nuggets::Hash::SeenMixin, true do
   end
 
   example do
-    hash = Hash.seen.update(:a => :b)
+    hash = Hash.seen.update(a: :b)
     hash.should be_an_instance_of(Hash)
 
     hash[:a].should == :b

data/spec/nuggets/hash/unroll_spec.rb

@@ -18,12 +18,12 @@ describe_extended Hash, Nuggets::Hash::UnrollMixin do
   end
 
   example do
-    hash = { :a => { :b => 1 } }
+    hash = { a: { b: 1 } }
     hash.unroll.should == [[:a, 1]]
   end
 
   example do
-    hash = { :a => { :b => 1, :c => 2 } }
+    hash = { a: { b: 1, c: 2 } }
 
     result = hash.unroll.first
     result.size.should == 3
@@ -33,36 +33,24 @@ describe_extended Hash, Nuggets::Hash::UnrollMixin do
     result.should include(2)
   end
 
-if RUBY_VERSION < '1.9'
-  example do
-    hash = { :a => { :b => 1, :c => 2 } }
-    lambda { hash.unroll(:sort => true) }.should raise_error(NoMethodError, /<=>/)
-  end
-
-  example do
-    hash = { :a => { :b => 1, :c => 2 } }
-    lambda { hash.unroll(:sort_by => lambda { |h| h.to_s }) }.should_not raise_error(NoMethodError)
-  end
-end
-
   example do
     hash = { 'a' => { 'b' => 1, 'c' => 2 } }
-    hash.unroll(:sort => true).should == [['a', 1, 2]]
+    hash.unroll(sort: true).should == [['a', 1, 2]]
   end
 
   example do
     hash = { 'a' => { 'b' => 1, 'c' => 2 }, 'd' => { 'b' => 0, 'c' => 3 } }
-    hash.unroll('b', 'c', :sort => true).should == [['a', 1, 2], ['d', 0, 3]]
+    hash.unroll('b', 'c', sort: true).should == [['a', 1, 2], ['d', 0, 3]]
   end
 
   example do
     hash = { 'z' => { 'a' => { 'b' => 1, 'c' => 2 }, 'd' => { 'b' => 0, 'c' => 3 } } }
-    hash.unroll('b', :sort_by => lambda { |h| h.to_s }).should == [['z', 'a', 1], ['z', 'd', 0]]
+    hash.unroll('b', sort_by: lambda { |h| h.to_s }).should == [['z', 'a', 1], ['z', 'd', 0]]
   end
 
   example do
     hash = { 'z' => { 'a' => { 'b' => 1, 'c' => 2 }, 'd' => { 'b' => 0, 'c' => 3 } } }
-    hash.unroll(:sort => true) { |h| h['b'] = nil; h['c'] *= 2 }.should == [['z', 'a', nil, 4], ['z', 'd', nil, 6]]
+    hash.unroll(sort: true) { |h| h['b'] = nil; h['c'] *= 2 }.should == [['z', 'a', nil, 4], ['z', 'd', nil, 6]]
   end
 
 end

data/spec/nuggets/json/canonical_spec.rb

@@ -0,0 +1,74 @@
+require 'nuggets/json/canonical'
+require 'nuggets/json/multi'
+
+describe_extended JSON, Nuggets::JSON::CanonicalMixin, true do
+
+  let(:source) { '{"a":1,"b":[42,23],"a":{"b":2,"a":[3,5,4]}}' }
+
+  subject { JSON.parse(source) }
+
+  describe 'plain' do
+
+    example { expect(JSON.generate(subject)).to eq('{"a":{"b":2,"a":[3,5,4]},"b":[42,23]}') }
+
+    example { expect(JSON.pretty_generate(subject)).to eq(<<-EOT.chomp) }
+{
+  "a": {
+    "b": 2,
+    "a": [
+      3,
+      5,
+      4
+    ]
+  },
+  "b": [
+    42,
+    23
+  ]
+}
+    EOT
+
+  end
+
+  describe 'canonical' do
+
+    example { expect(JSON.generate_canonical(subject)).to eq('{"a":{"a":[3,4,5],"b":2},"b":[23,42]}') }
+
+    example { expect(JSON.pretty_generate_canonical(subject)).to eq(<<-EOT.chomp) }
+{
+  "a": {
+    "a": [
+      3,
+      4,
+      5
+    ],
+    "b": 2
+  },
+  "b": [
+    23,
+    42
+  ]
+}
+    EOT
+
+    example { expect(JSON.pretty_print_canonical(source)).to eq(<<-EOT.chomp) }
+{
+  "a": 1,
+  "a": {
+    "a": [
+      3,
+      4,
+      5
+    ],
+    "b": 2
+  },
+  "b": [
+    23,
+    42
+  ]
+}
+    EOT
+
+  end
+
+end

data/spec/nuggets/json/multi_spec.rb

@@ -0,0 +1,67 @@
+require 'nuggets/json/multi'
+
+describe_extended JSON, Nuggets::JSON::MultiMixin, true do
+
+  let(:source) { '{"a":1,"b":[42,23],"a":{"b":2}}' }
+
+  describe 'plain' do
+
+    subject { JSON.parse(source) }
+
+    example { expect(subject).to be_a(Hash) }
+    example { expect(subject.size).to eq(2) }
+    example { expect(subject.keys).to eq(%w[a b]) }
+
+    example { expect(subject['a']).to eq('b' => 2) }
+    example { expect(subject['b']).to eq([42, 23]) }
+
+    example { expect(JSON.pretty_generate(subject)).to eq(<<-EOT.chomp) }
+{
+  "a": {
+    "b": 2
+  },
+  "b": [
+    42,
+    23
+  ]
+}
+    EOT
+
+  end
+
+  describe 'multi' do
+
+    subject { JSON.parse_multi(source) }
+
+    let(:multi) { subject.fetch_multi('a') }
+
+    let(:pretty) { <<-EOT.chomp }
+{
+  "a": 1,
+  "b": [
+    42,
+    23
+  ],
+  "a": {
+    "b": 2
+  }
+}
+    EOT
+
+    example { expect(subject).to be_a(Hash) }
+    example { expect(subject.size).to eq(3) }
+    example { expect(subject.keys).to eq(%w[a b a]) }
+
+    example { expect(subject['a']).to eq(1) } unless RUBY_ENGINE == 'jruby'
+    example { expect(subject['b']).to eq([42, 23]) }
+
+    example { expect(multi[0]).to eq(1) }
+    example { expect(multi[1]).to be_a(Hash) }
+    example { expect(multi[1]['b']).to eq(2) }
+
+    example { expect(JSON.pretty_generate(subject)).to eq(pretty) }
+    example { expect(JSON.pretty_print_multi(source)).to eq(pretty) }
+
+  end
+
+end

data/spec/nuggets/object/blank_spec.rb

@@ -23,11 +23,11 @@ describe_extended Object, Nuggets::Object::BlankMixin do
     example { o.should be_vain }
   }
 
-  [['', [], [nil], {}], { :x => nil, :y => [], :z => { :zz => nil } }].each { |o|
+  [['', [], [nil], {}], { x: nil, y: [], z: { zz: nil } }].each { |o|
     example { o.should_not be_void }
   }
 
-  [['', [], [nil], {}], { :x => nil, :y => [], :z => { :zz => nil } }].each { |o|
+  [['', [], [nil], {}], { x: nil, y: [], z: { zz: nil } }].each { |o|
     example { o.should be_vain }
   }
 

data/spec/nuggets/object/singleton_class_spec.rb

@@ -2,12 +2,13 @@ require 'nuggets/object/singleton_class'
 
 describe_extended Object, Nuggets::Object::SingletonClassMixin do
 
-  objects = [Class, Object.new, Class.new, 's', [1, 2], { :a => 'b' }]
+  objects = [Class, Object.new, Class.new, 's', [1, 2], { a: 'b' }]
   objects.unshift(Object) unless %w[jruby rbx].include?(RUBY_ENGINE)
 
   objects.each { |o|
     example { o.should_not be_a_singleton_class }
-    example { lambda { o.singleton_object }.should raise_error(TypeError) }
+    example(nil, if: o != Object || RUBY_VERSION < '2.3') {
+      lambda { o.singleton_object }.should raise_error(TypeError) }
 
     s = o.singleton_class
 

data/spec/nuggets/string/format_spec.rb

@@ -0,0 +1,85 @@
+require 'nuggets/string/format'
+
+describe_extended String, Nuggets::String::FormatMixin do
+
+  example do
+    expect{'a%bc'.format}.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
+  end
+
+  example do
+    expect('a%bc'.format('b' => 'foo')).to eq('afooc')
+  end
+
+  example do
+    expect('a%bc'.format(b: 'foo')).to eq('afooc')
+  end
+
+  example do
+    expect('a%bc'.format(b: :foo)).to eq('afooc')
+  end
+
+  example do
+    expect('a%bc'.format(b: 42)).to eq('a42c')
+  end
+
+  example do
+    expect('a%bc'.format(b: '')).to eq('ac')
+  end
+
+  example do
+    expect('a%bc'.format(b: nil)).to eq('ac')
+  end
+
+  example do
+    expect('a%{foo}c'.format('foo' => 'bar')).to eq('abarc')
+  end
+
+  example do
+    expect('a%{foo}c'.format(foo: 'bar')).to eq('abarc')
+  end
+
+  example do
+    expect('a%{foo}c'.format(foo: :bar)).to eq('abarc')
+  end
+
+  example do
+    expect(''.format({})).to eq('')
+  end
+
+  example do
+    expect('%'.format({})).to eq('%')
+  end
+
+  example do
+    expect('%%'.format({})).to eq('%')
+  end
+
+  example do
+    expect{'%a'.format({})}.to raise_error(KeyError, 'key not found: a')
+  end
+
+  example do
+    expect{'%a'.format('b' => 'foo')}.to raise_error(KeyError, 'key not found: a')
+  end
+
+  example do
+    expect{'%a'.format(Hash.new(42))}.to raise_error(KeyError, 'key not found: a')
+  end
+
+  example do
+    expect('a%bc'.format(&:upcase)).to eq('aBc')
+  end
+
+  example do
+    expect('a%bc'.format{''}).to eq('ac')
+  end
+
+  example do
+    expect{'a%bc'.format{}}.to raise_error(ArgumentError, 'malformed format string - %b')
+  end
+
+  example do
+    expect('a%bc%d%{foo}%%{baz}'.format(b: 42, d: 'D', 'foo' => :bar)).to eq('a42cDbar%{baz}')
+  end
+
+end

data/spec/nuggets/string/highlight_spec.rb

@@ -0,0 +1,47 @@
+require 'nuggets/string/highlight'
+
+describe_extended String, Nuggets::String::HighlightMixin do
+
+unless RUBY_ENGINE == 'jruby' && JRUBY_VERSION.include?('pre')
+
+  example do
+    s = 'lingo go do the go go'; t = s.dup
+    expect(s.highlight('lingo')).to eq('|lingo| go do the go go')
+    expect(s).to eq(t)
+
+    expect(s.highlight(/lingo/)).to eq('|lingo| go do the go go')
+    expect(s.highlight(/l.*ngo?/)).to eq('|lingo| go do the go go')
+
+    q = ['lingo', 'go', 'go go']
+    expect(s.highlight(q)).to eq('|lingo go| do the |go go|')
+  end
+
+  example do
+    s = 'lingö go do the go go'
+    q = ['lingö', 'go', 'go go']
+    expect(s.highlight(q)).to eq('|lingö| |go| do the |go go|')
+  end
+
+  example do
+    s = 'lingo go do the go go'
+    q = ['lingo', 'go', 'go go']
+    expect(s.highlight(q, '^')).to eq('^lingo go^ do the ^go go^')
+    expect(s.highlight(q, '<', '>')).to eq('<lingo go> do the <go go>')
+    expect(s.highlight(q, '<i>', '</i>')).to eq('<i>lingo go</i> do the <i>go go</i>')
+  end
+
+  example do
+    s = 'The fox went out on a chilly night'
+    q = [/[eo]n/]
+    expect(s.highlight(q)).to eq('The fox w|en|t out |on| a chilly night')
+    q << 'went'
+    expect(s.highlight(q)).to eq('The fox |went| out |on| a chilly night')
+    q << /ou.*a/
+    expect(s.highlight(q)).to eq('The fox |went| |out on a| chilly night')
+    q << 'went out'
+    expect(s.highlight(q)).to eq('The fox |went out on a| chilly night')
+  end
+
+end
+
+end