nuggets 0.9.9 → 1.0.0

data/spec/nuggets/object/boolean_spec.rb

@@ -0,0 +1,23 @@
+require 'nuggets/object/boolean'
+
+describe_extended Object, Nuggets::Object::BooleanMixin do
+
+  [0, 1, -1, nil, '', 'abc', Class, Object.new].each { |o|
+    example { o.should_not be_boolean }
+  }
+
+  [true, false].each { |o|
+    example { o.should be_boolean }
+  }
+
+  [0, 1, -1, '', 'abc', Class, Object.new, true].each { |o|
+    example { o.negate.should == false }
+    example { o.to_bool.should == true }
+  }
+
+  [nil, false].each { |o|
+    example { o.negate.should == true }
+    example { o.to_bool.should == false }
+  }
+
+end

data/spec/nuggets/object/msend_spec.rb

@@ -0,0 +1,25 @@
+require 'nuggets/object/msend'
+
+describe_extended Object, Nuggets::Object::MSendMixin do
+
+  example do
+    o = 'foo bar'
+    o.msend(:length, :reverse).should == [o.length, o.reverse]
+  end
+
+  example do
+    o = 42
+    o.msend(:to_s, :* => 2).should == [o.to_s, o * 2]
+  end
+
+  example do
+    o = 42
+    o.msend([:to_s, 2], '-@').should == [o.to_s(2), -o]
+  end
+
+  example do
+    o = Time.now
+    o.msend(:year, :month, :day).should == [o.year, o.month, o.day]
+  end
+
+end

data/spec/nuggets/object/silence_spec.rb

@@ -0,0 +1,36 @@
+require 'nuggets/object/silence'
+
+describe_extended Object, Nuggets::Object::SilenceMixin do
+
+  before do
+    @stderr, @old_stderr = '', $stderr
+    $stderr = StringIO.new(@stderr)
+
+    AConst = :foo
+  end
+
+  after do
+    $stderr = @old_stderr
+    Object.send(:remove_const, :AConst) if Object.const_defined?(:AConst)
+  end
+
+  example do
+    AConst = :bar
+
+    AConst.should be_equal(:bar)
+
+    if RUBY_ENGINE == 'rbx'
+      @stderr.should == ''
+    else
+      @stderr.should =~ /warning: already initialized constant AConst/
+    end
+  end
+
+  example do
+    silence { AConst = :baz }
+
+    AConst.should be_equal(:baz)
+    @stderr.should == ''
+  end
+
+end

data/spec/nuggets/object/singleton_class_spec.rb

@@ -0,0 +1,51 @@
+require 'nuggets/object/singleton_class'
+
+describe_extended Object, Nuggets::Object::SingletonClassMixin do
+
+  objects = [Class, Object.new, Class.new, 's', [1, 2], { :a => 'b' }]
+  objects.unshift(Object) unless RUBY_PLATFORM == 'java' || RUBY_ENGINE == 'rbx'
+
+  objects.each { |o|
+    example { o.should_not be_a_singleton_class }
+    example { lambda { o.singleton_object }.should raise_error(TypeError) }
+
+    s = o.singleton_class
+
+    example { s.should be_a_singleton_class }
+    example { s.singleton_object.should be_equal(o) }
+  }
+
+  example do
+    c = Class.new
+    c.should_not be_a_singleton_class
+    o = c.new
+    c.should_not be_a_singleton_class
+  end
+
+  example do
+    nil.singleton_class.should == NilClass
+
+    if RUBY_VERSION < '2'
+      NilClass.should be_a_singleton_class
+    else
+      NilClass.should be_a_virtual_class
+    end
+
+    NilClass.singleton_object.should be_equal(nil)
+  end
+
+  example do
+    class A; end
+    class B < A; end
+
+    a = A.singleton_class
+    b = B.singleton_class
+
+    a.should be_a_singleton_class
+    b.should be_a_singleton_class
+
+    a.singleton_object.should be_equal(A)
+    b.singleton_object.should be_equal(B)
+  end
+
+end

data/spec/nuggets/proc/bind_spec.rb

@@ -0,0 +1,28 @@
+require 'nuggets/proc/bind'
+
+describe_extended Proc, Nuggets::Proc::BindMixin do
+
+  before :each do
+    @l = lambda { bla }
+  end
+
+  example do
+    lambda { @l.call }.should raise_error(NameError)
+  end
+
+  example do
+    module Foo; def self.bla; 'bar'; end; end
+    @l.bind(Foo).call.should == 'bar'
+  end
+
+  example do
+    class Bar; def self.bla; 'baz'; end; end
+    @l.bind(Bar).call.should == 'baz'
+  end
+
+  example do
+    class Baz; def bla; 'foo'; end; end
+    @l.bind(Baz.new).call.should == 'foo'
+  end
+
+end

data/spec/nuggets/range/quantile_spec.rb

@@ -0,0 +1,33 @@
+require 'nuggets/range/quantile'
+
+describe_extended Range, Nuggets::Range::QuantileMixin do
+
+  example do
+    (1..5).quantile(0, 3).should == 1
+  end
+
+  example do
+    (1..5).quantile(1, 3).should == 1
+  end
+
+  example do
+    (1..5).quantile(2, 3).should == 1
+  end
+
+  example do
+    (1..5).quantile(3, 3).should == 2
+  end
+
+  example do
+    (1..5).quantile(4, 3).should == 3
+  end
+
+  example do
+    (1..5).quantile(5, 3).should == 3
+  end
+
+  example do
+    (1..5).quantile(6, 3).should == 3
+  end
+
+end

data/spec/nuggets/string/camelscore_spec.rb

@@ -0,0 +1,114 @@
+require 'nuggets/string/camelscore'
+
+describe_extended String, Nuggets::String::CamelscoreMixin do
+
+  def self.with_acronyms(acronyms, &block)
+    describe "with acronyms #{acronyms.inspect}" do
+      before :all do ::String::CAMELSCORE_ACRONYMS.replace(acronyms) end
+      after  :all do ::String::CAMELSCORE_ACRONYMS.clear             end
+
+      instance_eval(&block)
+    end
+  end
+
+  with_acronyms({}) { [
+    ['', ''],
+    %w[a A],
+    %w[a_b AB],
+    %w[a_b_c ABC],
+    %w[a/b A::B],
+    %w[a/b_c A::BC],
+    %w[a/b/c A::B::C],
+    %w[foo Foo],
+    %w[foo_bar FooBar],
+    %w[foo_bar_baz FooBarBaz],
+    %w[foo/bar Foo::Bar],
+    %w[foo/bar_baz Foo::BarBaz],
+    %w[foo/bar/baz Foo::Bar::Baz],
+    %w[active_model ActiveModel],
+    %w[active_model/errors ActiveModel::Errors],
+    %w[ssl_error SslError],
+    %w[s_s_l_error SSLError]
+  ].each { |a, b|
+    example { a.camelcase.should == b }
+    example { b.underscore.should == a }
+  } }
+
+  with_acronyms('ab' => 'AB') {
+    example { 'ab'.camelcase.should == 'AB' }
+    example { 'AB'.underscore.should == 'ab' }
+    example { 'abc'.camelcase.should == 'Abc' }
+    example { 'Abc'.underscore.should == 'abc' }
+    example { 'ab_c'.camelcase.should == 'ABC' }
+    example { 'ABC'.underscore.should == 'ab_c' }
+  }
+
+  with_acronyms('abc' => 'ABC') {
+    example { 'ab'.camelcase.should == 'Ab' }
+    example { 'AB'.underscore.should == 'a_b' }
+    example { 'abc'.camelcase.should == 'ABC' }
+    example { 'ABC'.underscore.should == 'abc' }
+  }
+
+  with_acronyms('ab' => 'AB', 'abc' => 'ABC') {
+    example { 'ab'.camelcase.should == 'AB' }
+    example { 'AB'.underscore.should == 'ab' }
+    example { 'abc'.camelcase.should == 'ABC' }
+    example { 'Abc'.underscore.should == 'abc' }
+    example { 'ab_c'.camelcase.should == 'ABC' }
+    example { 'ABC'.underscore.should == 'ab_c' }
+  }
+
+  with_acronyms('xml' => 'XML', 'html' => 'HTML', 'sql' => 'SQL') {
+    example { 'xml'.camelcase.should == 'XML' }
+    example { 'XML'.underscore.should == 'xml' }
+    example { 'html'.camelcase.should == 'HTML' }
+    example { 'HTML'.underscore.should == 'html' }
+    example { 'html5'.camelcase.should == 'HTML5' }
+    example { 'HTML5'.underscore.should == 'html5' }
+   #pending { 'xhtml'.camelcase.should == 'XHTML' }
+   #pending { 'XHTML'.underscore.should == 'xhtml' }
+    example { 'sql'.camelcase.should == 'SQL' }
+    example { 'SQL'.underscore.should == 'sql' }
+   #pending { 'mysql'.camelcase.should == 'MySQL' }
+   #pending { 'MySQL'.underscore.should == 'mysql' }
+   #pending { 'postgresql'.camelcase.should == 'PostgreSQL' }
+   #pending { 'PostgreSQL'.underscore.should == 'postgresql' }
+   #pending { 'sqlite'.camelcase.should == 'SQLite' }
+   #pending { 'SQLite'.underscore.should == 'sqlite' }
+   #pending { 'nosql'.camelcase.should == 'NoSQL' }
+   #pending { 'NoSQL'.underscore.should == 'nosql' }
+  }
+
+  with_acronyms('rss' => 'RSS', 'xml' => 'XML') {
+    example { 'rss2xml'.camelcase.should == 'RSS2XML' }
+    example { 'RSS2XML'.underscore.should == 'rss2xml' }
+  }
+
+  with_acronyms('ssl' => 'SSL') {
+    example { 'ssl'.camelcase.should == 'SSL' }
+    example { 'SSL'.underscore.should == 'ssl' }
+    example { 'ssl_error'.camelcase.should == 'SSLError' }
+    example { 'SSLError'.underscore.should == 'ssl_error' }
+  }
+
+  example { ''.constantize.should be_nil }
+  example { '::'.constantize.should be_nil }
+
+  example { 'Nuggets'.constantize.should == ::Nuggets }
+  example { '::Nuggets'.constantize.should == ::Nuggets }
+
+  example { 'Nuggets::String'.constantize.should == ::Nuggets::String }
+  example { '::Nuggets::String'.constantize.should == ::Nuggets::String }
+
+  example { 'String'.constantize.should == ::String }
+  example { 'String'.constantize(::Nuggets).should == ::Nuggets::String }
+  example { '::String'.constantize(::Nuggets).should == ::String }
+  example { 'String'.constantize(::Nuggets::String).should == ::String }
+  example { 'String'.constantize(::Nuggets::String::CamelscoreMixin).should == ::String }
+
+  example { lambda { 'CamelscoreMixin'.constantize }.should raise_error(NameError) }
+  example { lambda { 'CamelscoreMixin'.constantize(::Nuggets) }.should raise_error(NameError) }
+  example { 'CamelscoreMixin'.constantize(::Nuggets::String).should == ::Nuggets::String::CamelscoreMixin }
+
+end

data/spec/nuggets/string/capitalize_first_spec.rb

@@ -0,0 +1,13 @@
+require 'nuggets/string/capitalize_first'
+
+describe String, 'capitalize_first' do
+
+  {
+    'Some string' => 'Some string',
+    'some string' => 'Some string',
+    'SOME STRING' => 'SOME STRING'
+  }.each { |s, c|
+    example { s.capitalize_first.should == c }
+  }
+
+end

data/spec/nuggets/string/case_spec.rb

@@ -0,0 +1,31 @@
+require 'nuggets/string/case'
+
+describe String, 'case' do
+
+  example {
+    s = 'Some string'
+
+    s.case.should == :mixed
+    s.should_not be_downcase
+    s.should_not be_upcase
+    s.should be_mixed_case
+    s.should be_capitalized
+  }
+
+  example {
+    s = 'some string'
+
+    s.case.should == :lower
+    s.should be_downcase
+    s.should_not be_mixed_case
+  }
+
+  example {
+    s = 'SOME STRING'
+
+    s.case.should == :upper
+    s.should be_upcase
+    s.should_not be_mixed_case
+  }
+
+end

data/spec/nuggets/string/evaluate_spec.rb

@@ -0,0 +1,24 @@
+require 'nuggets/string/evaluate'
+
+describe_extended String, Nuggets::String::EvaluateMixin do
+
+  describe do
+
+    %w[bl#{a}blub bl#{a}#{b}lub].each { |str|
+      { 'blablub' => %w[a b], 'blubblub' => %w[ub b] }.each { |res, (a, b)|
+        example { str.evaluate(binding).should == res }
+      }
+
+      example do
+        lambda { str.evaluate(binding) }.should raise_error(NameError, /`a'/)
+      end
+    }
+
+  end
+
+  [ 'a"b"c', 'a\"b\"c', 'a\\"b\\"c', 'a\\\"b\\\"c',
+    "a'b'c", 'a%q{b}c', 'a{b}c', 'a{bc', 'ab}c' ].each { |str|
+    example { str.evaluate(binding).should == str }
+  }
+
+end

data/spec/nuggets/string/msub_spec.rb

@@ -0,0 +1,20 @@
+require 'nuggets/string/msub'
+
+describe String, 'msub' do
+
+  let(:s) { 'Foo, Bar - Baz' }
+
+  example { s.gsub(/a/, 'o').gsub(/o/, 'a').should == 'Faa, Bar - Baz' }
+  example { s.msub('a' => 'o', 'o' => 'a').should == 'Faa, Bor - Boz' }
+
+  example { s.msub!('a' => 'o', 'o' => 'a'); s.should == 'Faa, Bor - Boz' }
+
+  example { s.msub(/[A-Z]/ => '#{__match__.downcase}', __binding__: binding).should == 'foo, bar - baz' }
+  example { s.msub(/[A-Z]/ => lambda { |match| match.downcase }).should == 'foo, bar - baz' }
+
+  t = '!!!'
+
+  example { lambda { s.msub('r' => '???', 'z' => '#{t}') }.should raise_error(NameError) }
+  example { s.msub('r' => '???', 'z' => '#{t}', __binding__: binding).should == 'Foo, Ba??? - Ba!!!' }
+
+end

data/spec/nuggets/string/nsub_spec.rb

@@ -0,0 +1,13 @@
+require 'nuggets/string/nsub'
+
+describe String, 'nsub' do
+
+  let(:s) { 'a b c d e f g h i' }
+
+  example { s.nsub(' ', '', 6).should == 'abcdefg h i' }
+
+  example { s.nsub(' ', 6) { '' }.should == 'abcdefg h i' }
+
+  example { s.nsub!(' ', '', 6); s.should == 'abcdefg h i' }
+
+end

data/spec/nuggets/string/sub_with_md_spec.rb

@@ -0,0 +1,25 @@
+require 'nuggets/string/sub_with_md'
+
+describe String, 'sub_with_md' do
+
+  let(:s) { 'Foo, Bar - Baz' }
+
+  example {
+    s.gsub(/\w(\w+)(\W*)/) { |m|
+      "#{$1.gsub(/[ao]/, 'X')}#{$2}"
+    }.should == 'XXXrXz'
+  }
+
+  example {
+    s.gsub_with_md(/\w(\w+)(\W*)/) { |md|
+      "#{md[1].gsub(/[ao]/, 'X')}#{md[2]}"
+    }.should == 'XX, Xr - Xz'
+  }
+
+  example {
+    s.gsub_with_md(/\w(\w+)(\W*)/) { |md|
+      "#{md[1].gsub_with_md(/[ao]/) { |md2| md2[0].upcase }}#{md[2]}"
+    }.should == 'OO, Ar - Az'
+  }
+
+end