robsharp-extlib 0.9.15

data/spec/lazy_module_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'extlib/lazy_module'
+
+describe LazyModule do
+  describe "instantiated with a block" do
+    it "defers block body evaluation" do
+      lambda do
+        LazyModule.new do
+          raise "Will only be evaluated when mixed in"
+        end
+      end.should_not raise_error
+    end
+  end
+
+
+  describe "included into hosting class" do
+    before :all do
+      KlazzyLazyModule = LazyModule.new do
+        def self.klassy
+          "Klazz"
+        end
+
+        def instancy
+          "Instanzz"
+        end
+      end
+
+      @klass = Class.new do
+        include KlazzyLazyModule
+      end
+    end
+
+    it "class evals block body" do
+      @klass.klassy.should == "Klazz"
+      @klass.new.instancy.should == "Instanzz"
+    end
+  end
+end

data/spec/mash_spec.rb

@@ -0,0 +1,312 @@
+require 'spec_helper'
+require 'extlib/mash'
+
+class AwesomeHash < Hash
+end
+
+describe Mash do
+  before(:each) do
+    @hash = { "mash" => "indifferent", :hash => "different" }
+    @sub  = AwesomeHash.new("mash" => "indifferent", :hash => "different")
+  end
+
+  describe "#initialize" do
+    it 'converts all keys into strings when param is a Hash' do
+      mash = Mash.new(@hash)
+
+      mash.keys.any? { |key| key.is_a?(Symbol) }.should be_false
+    end
+
+    it 'converts all pure Hash values into Mashes if param is a Hash' do
+      mash = Mash.new :hash => @hash
+
+      mash["hash"].should be_an_instance_of(Mash)
+      # sanity check
+      mash["hash"]["hash"].should == "different"
+    end
+
+    it 'doesn not convert Hash subclass values into Mashes' do
+      mash = Mash.new :sub => @sub
+      mash["sub"].should be_an_instance_of(AwesomeHash)
+    end
+
+    it 'converts all value items if value is an Array' do
+      mash = Mash.new :arry => { :hash => [@hash] }
+
+      mash["arry"].should be_an_instance_of(Mash)
+      # sanity check
+      mash["arry"]["hash"].first["hash"].should == "different"
+
+    end
+
+    it 'delegates to superclass constructor if param is not a Hash' do
+      mash = Mash.new("dash berlin")
+
+      mash["unexisting key"].should == "dash berlin"
+    end
+  end # describe "#initialize"
+
+
+
+  describe "#update" do
+    it 'converts all keys into strings when param is a Hash' do
+      mash = Mash.new(@hash)
+      mash.update("starry" => "night")
+
+      mash.keys.any? { |key| key.is_a?(Symbol) }.should be_false
+    end
+
+    it 'converts all Hash values into Mashes if param is a Hash' do
+      mash = Mash.new :hash => @hash
+      mash.update(:hash => { :hash => "is buggy in Ruby 1.8.6" })
+
+      mash["hash"].should be_an_instance_of(Mash)
+    end
+  end # describe "#update"
+
+
+
+  describe "#[]=" do
+    it 'converts key into string' do
+      mash = Mash.new(@hash)
+      mash[:hash] = { "starry" => "night" }
+
+      mash.keys.any? { |key| key.is_a?(Symbol) }.should be_false
+    end
+
+    it 'converts all Hash value into Mash' do
+      mash = Mash.new :hash => @hash
+      mash[:hash] = { :hash => "is buggy in Ruby 1.8.6" }
+
+      mash["hash"].should be_an_instance_of(Mash)
+    end
+  end # describe "#[]="
+
+
+
+  describe "#key?" do
+    before(:each) do
+      @mash = Mash.new(@hash)
+    end
+
+    it 'converts key before lookup' do
+      @mash.key?("mash").should be_true
+      @mash.key?(:mash).should be_true
+
+      @mash.key?("hash").should be_true
+      @mash.key?(:hash).should be_true
+
+      @mash.key?(:rainclouds).should be_false
+      @mash.key?("rainclouds").should be_false
+    end
+
+    it 'is aliased as include?' do
+      @mash.include?("mash").should be_true
+      @mash.include?(:mash).should be_true
+
+      @mash.include?("hash").should be_true
+      @mash.include?(:hash).should be_true
+
+      @mash.include?(:rainclouds).should be_false
+      @mash.include?("rainclouds").should be_false
+    end
+
+    it 'is aliased as member?' do
+      @mash.member?("mash").should be_true
+      @mash.member?(:mash).should be_true
+
+      @mash.member?("hash").should be_true
+      @mash.member?(:hash).should be_true
+
+      @mash.member?(:rainclouds).should be_false
+      @mash.member?("rainclouds").should be_false
+    end
+  end # describe "#key?"
+
+
+  describe "#dup" do
+    it 'returns instance of Mash' do
+      Mash.new(@hash).dup.should be_an_instance_of(Mash)
+    end
+
+    it 'preserves keys' do
+      mash = Mash.new(@hash)
+      dup  = mash.dup
+
+      mash.keys.sort.should == dup.keys.sort
+    end
+
+    it 'preserves value' do
+      mash = Mash.new(@hash)
+      dup  = mash.dup
+
+      mash.values.sort.should == dup.values.sort
+    end
+  end
+
+
+
+  describe "#to_hash" do
+    it 'returns instance of Mash' do
+      Mash.new(@hash).to_hash.should be_an_instance_of(Hash)
+    end
+
+    it 'preserves keys' do
+      mash = Mash.new(@hash)
+      converted  = mash.to_hash
+
+      mash.keys.sort.should == converted.keys.sort
+    end
+
+    it 'preserves value' do
+      mash = Mash.new(@hash)
+      converted = mash.to_hash
+
+      mash.values.sort.should == converted.values.sort
+    end
+  end
+
+
+
+  describe "#symbolize_keys" do
+    it 'returns instance of Mash' do
+      Mash.new(@hash).symbolize_keys.should be_an_instance_of(Hash)
+    end
+
+    it 'converts keys to symbols' do
+      mash = Mash.new(@hash)
+      converted  = mash.symbolize_keys
+
+      converted_keys = converted.keys.sort{|k1, k2| k1.to_s <=> k2.to_s}
+      orig_keys = mash.keys.map{|k| k.to_sym}.sort{|i1, i2| i1.to_s <=> i2.to_s}
+
+      converted_keys.should == orig_keys
+    end
+
+    it 'preserves value' do
+      mash = Mash.new(@hash)
+      converted = mash.symbolize_keys
+
+      mash.values.sort.should == converted.values.sort
+    end
+  end
+
+
+
+  describe "#delete" do
+    it 'converts Symbol key into String before deleting' do
+      mash = Mash.new(@hash)
+
+      mash.delete(:hash)
+      mash.key?("hash").should be_false
+    end
+
+    it 'works with String keys as well' do
+      mash = Mash.new(@hash)
+
+      mash.delete("mash")
+      mash.key?("mash").should be_false
+    end
+  end
+
+
+
+  describe "#except" do
+    it "converts Symbol key into String before calling super" do
+      mash = Mash.new(@hash)
+
+      hashless_mash = mash.except(:hash)
+      hashless_mash.key?("hash").should be_false
+    end
+
+    it "works with String keys as well" do
+      mash = Mash.new(@hash)
+
+      mashless_mash = mash.except("mash")
+      mashless_mash.key?("mash").should be_false
+    end
+
+    it "works with multiple keys" do
+      mash = Mash.new(@hash)
+
+      mashless = mash.except("hash", :mash)
+      mashless.key?(:hash).should be_false
+      mashless.key?("mash").should be_false
+    end
+
+    it "should return a mash" do
+      mash = Mash.new(@hash)
+
+      hashless_mash = mash.except(:hash)
+      hashless_mash.class.should be(Mash)
+    end
+  end
+
+
+
+  describe "#merge" do
+    before(:each) do
+      @mash = Mash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'returns instance of Mash' do
+      @mash.should be_an_instance_of(Mash)
+    end
+
+    it 'merges in give Hash' do
+      @mash["no"].should == "in between"
+    end
+  end
+
+
+
+  describe "#fetch" do
+    before(:each) do
+      @mash = Mash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'converts key before fetching' do
+      @mash.fetch("no").should == "in between"
+    end
+
+    it 'returns alternative value if key lookup fails' do
+      @mash.fetch("flying", "screwdriver").should == "screwdriver"
+    end
+  end
+
+
+  describe "#default" do
+    before(:each) do
+      @mash = Mash.new(:yet_another_technical_revolution)
+    end
+
+    it 'returns default value unless key exists in mash' do
+      @mash.default("peak oil is now behind, baby").should == :yet_another_technical_revolution
+    end
+
+    it 'returns existing value if key is Symbol and exists in mash' do
+      @mash.update(:no => "in between")
+      @mash.default(:no).should == "in between"
+    end
+  end
+
+
+  describe "#values_at" do
+    before(:each) do
+      @mash = Mash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'is indifferent to whether keys are strings or symbols' do
+      @mash.values_at("hash", :mash, :no).should == ["different", "indifferent", "in between"]
+    end
+  end
+
+
+  describe "#stringify_keys!" do
+    it 'returns the mash itself' do
+      mash = Mash.new(@hash)
+
+      mash.stringify_keys!.object_id.should == mash.object_id
+    end
+  end
+end

data/spec/module_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'extlib/module'
+
+describe Module do
+
+  before(:all) do
+    module ::Foo
+      module ModBar
+        module Noo
+          module Too
+            module Boo
+            end
+          end
+        end
+      end
+
+      class Zed
+      end
+    end
+
+    class ::Baz
+    end
+
+    class ::Bar
+    end
+  end
+
+  it "should raise NameError for a missing constant" do
+    lambda { Foo.find_const('Moo') }.should raise_error(NameError)
+    lambda { Object.find_const('MissingConstant') }.should raise_error(NameError)
+  end
+
+  it "should be able to get a recursive constant" do
+    Object.find_const('Foo::ModBar').should == Foo::ModBar
+  end
+
+  it "should ignore get Constants from the Kernel namespace correctly" do
+    Object.find_const('::Foo::ModBar').should == ::Foo::ModBar
+  end
+
+  it "should find relative constants" do
+    Foo.find_const('ModBar').should == Foo::ModBar
+    Foo.find_const('Baz').should == Baz
+  end
+
+  it "should find sibling constants" do
+    Foo::ModBar.find_const("Zed").should == Foo::Zed
+  end
+
+  it "should find nested constants on nested constants" do
+    Foo::ModBar.find_const('Noo::Too').should == Foo::ModBar::Noo::Too
+  end
+
+  it "should find constants outside of nested constants" do
+    Foo::ModBar::Noo::Too.find_const("Zed").should == Foo::Zed
+  end
+
+  it 'should be able to find past the second nested level' do
+    Foo::ModBar::Noo.find_const('Too').should == Foo::ModBar::Noo::Too
+    Foo::ModBar::Noo::Too.find_const('Boo').should == Foo::ModBar::Noo::Too::Boo
+  end
+
+
+  it "should be able to deal with constants being added and removed" do
+    Object.find_const('Bar') # First we load Bar with find_const
+    Object.module_eval { remove_const('Bar') } # Now we delete it
+    module ::Bar; end; # Now we redefine it
+    Object.find_const('Bar').should == Bar
+  end
+
+end

data/spec/object_space_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'extlib/object_space'
+
+describe ObjectSpace, "#classes" do
+  it 'returns only classes, nothing else' do
+    ObjectSpace.classes.each do |klass|
+      Class.should === klass
+    end
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'extlib/object'
+
+module HactiveSupport
+  class MemoizeConsideredUseless
+  end
+end
+
+class SymbolicDuck
+  def quack
+  end
+end
+
+class ClassyDuck
+end
+
+module Foo
+  class Bar
+  end
+end
+
+class Oi
+  attr_accessor :foo
+end
+
+describe Object do
+
+  describe "#full_const_get" do
+    it 'returns constant by FQ name in receiver namespace' do
+      Object.full_const_get("Oi").should == Oi
+      Object.full_const_get("Foo::Bar").should == Foo::Bar
+    end
+  end
+
+  describe "#full_const_set" do
+    it 'sets constant value by FQ name in receiver namespace' do
+      Object.full_const_set("HactiveSupport::MCU", HactiveSupport::MemoizeConsideredUseless)
+
+      Object.full_const_get("HactiveSupport::MCU").should == HactiveSupport::MemoizeConsideredUseless
+      HactiveSupport.full_const_get("MCU").should == HactiveSupport::MemoizeConsideredUseless
+    end
+  end
+
+  describe "#make_module" do
+    it 'creates a module from string FQ name' do
+      Object.make_module("Milano")
+      Object.make_module("Norway::Oslo")
+
+      Object.const_defined?("Milano").should == true
+      Norway.const_defined?("Oslo").should == true
+    end
+
+    it "handles the case where we already have a class in the heirarchy" do
+      Object.make_module("Foo::Bar::Baz")
+      Object.const_defined?("Foo").should == true
+      Foo.const_defined?("Bar").should == true
+      Foo::Bar.const_defined?("Baz").should == true
+      Foo::Bar::Baz.should be_kind_of(Module)
+    end
+  end
+
+
+  describe "#quacks_like?" do
+    it 'returns true if duck is a Symbol and receiver responds to it' do
+      SymbolicDuck.new.quacks_like?(:quack).should be_true
+    end
+
+    it 'returns false if duck is a Symbol and receiver DOES NOT respond to it' do
+      SymbolicDuck.new.quacks_like?(:wtf).should be_false
+    end
+
+    it 'returns true if duck is a class and receiver is its instance' do
+      receiver = ClassyDuck.new
+      receiver.quacks_like?(ClassyDuck).should be_true
+    end
+
+    it 'returns false if duck is a class and receiver IS NOT its instance' do
+      receiver = ClassyDuck.new
+      receiver.quacks_like?(SymbolicDuck).should be_false
+    end
+
+    it 'returns true if duck is an array and at least one of its members quacks like this duck' do
+      receiver = ClassyDuck.new
+      ary      = [ClassyDuck, SymbolicDuck]
+
+      receiver.quacks_like?(ary).should be_true
+    end
+
+    it 'returns false if duck is an array and none of its members quacks like this duck' do
+      receiver = ClassyDuck.new
+      ary      = [SymbolicDuck.new, SymbolicDuck]
+
+      receiver.quacks_like?(ary).should be_false
+    end
+  end
+
+  describe "#in?" do
+    it 'returns true if object is included in collection' do
+      @ary = [1, 2, 3]
+      @set = Set.new([2, 3, 5])
+
+      1.in?(@ary).should be_true
+      2.in?(@ary).should be_true
+      3.in?(@ary).should be_true
+      4.in?(@ary).should be_false
+
+      1.in?(@set).should be_false
+      2.in?(@set).should be_true
+      3.in?(@set).should be_true
+      4.in?(@set).should be_false
+      5.in?(@set).should be_true
+    end
+  end
+end