ice_nine 0.8.0 → 0.9.0

data/config/yardstick.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 100.0
+threshold: 100

data/lib/ice_nine.rb

@@ -13,6 +13,7 @@ require 'ice_nine/freezer/false_class'
 require 'ice_nine/freezer/hash'
 require 'ice_nine/freezer/hash/state'
 require 'ice_nine/freezer/nil_class'
+require 'ice_nine/freezer/module'
 require 'ice_nine/freezer/numeric'
 require 'ice_nine/freezer/range'
 require 'ice_nine/freezer/rubinius'

data/lib/ice_nine/freezer.rb

@@ -5,15 +5,14 @@ module IceNine
   # The default class that handles freezing objects
   class Freezer
 
-    # Configure const_get and const_defined? to not search ancestors
-    SKIP_ANCESTORS = (RUBY_VERSION < '1.9' ? [] : [false]).freeze
-
     # Cache the Freezer classes returned for each type
     @freezer_cache = Hash.new do |cache, mod|
+      cache[mod] = nil
       mod.ancestors.each do |ancestor|
         freezer = find(ancestor.name.to_s)
         break cache[mod] = freezer if freezer
       end
+      cache[mod]
     end
 
     # Look up the Freezer descendant by object type
@@ -60,9 +59,7 @@ module IceNine
     #
     # @api private
     def self.const_lookup(namespace)
-      if const_defined?(namespace, *SKIP_ANCESTORS)
-        const_get(namespace, *SKIP_ANCESTORS)
-      end
+      const_get(namespace) if const_defined?(namespace, nil)
     end
 
     class << self

data/lib/ice_nine/freezer/hash.rb

@@ -20,10 +20,11 @@ module IceNine
       # @api public
       def self.deep_freeze(hash)
         IceNine.deep_freeze(hash.default_proc || hash.default)
-        super hash.each { |key, value|
+        hash.each do |key, value|
           IceNine.deep_freeze(key)
           IceNine.deep_freeze(value)
-        }
+        end
+        super
       end
 
     end # class Hash

data/lib/ice_nine/freezer/module.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # Skip freezing Module objects
+    class Module < NoFreeze; end
+
+  end # class Freezer
+end # module IceNine

data/lib/ice_nine/support/recursion_guard.rb

@@ -12,19 +12,19 @@ module IceNine
     #    logic_which_may_recursively_call_the_containing_method
     #  end
     #
-    # @param [Integer] object_id
+    # @param [Integer] caller_object_id
     #
     # @return [Object]
     #
     # @api public
-    def self.guard(object_id)
+    def self.guard(caller_object_id)
       objects = guarded_objects(caller.first)
-      return if objects.include?(object_id)
+      return if objects.include?(caller_object_id)
       begin
-        objects << object_id
+        objects << caller_object_id
         yield
       ensure
-        objects.delete(object_id)
+        objects.delete(caller_object_id)
       end
     end
 

data/lib/ice_nine/version.rb

@@ -3,6 +3,6 @@
 module IceNine
 
   # Unreleased gem version
-  VERSION = '0.8.0'.freeze
+  VERSION = '0.9.0'.freeze
 
 end # module IceNine

data/spec/integration/ice_nine/class_methods/deep_freeze_spec.rb

@@ -25,7 +25,7 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'freezes the instance variables in the Object' do
-      subject.instance_variable_get(:@a).should be_frozen
+      expect(subject.instance_variable_get(:@a)).to be_frozen
     end
 
     context 'with a circular reference' do
@@ -42,7 +42,7 @@ describe IceNine, '.deep_freeze' do
       end
 
       it 'freezes the instance variables in the Object' do
-        subject.instance_variable_get(:@a).should be_frozen
+        expect(subject.instance_variable_get(:@a)).to be_frozen
       end
     end
   end
@@ -59,7 +59,7 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'freezes each element in the Array' do
-      subject.select(&:frozen?).should == subject
+      expect(subject.select(&:frozen?)).to eql(subject)
     end
 
     context 'with a circular reference' do
@@ -76,7 +76,7 @@ describe IceNine, '.deep_freeze' do
       end
 
       it 'freezes each element in the Array' do
-        subject.select(&:frozen?).should == subject
+        expect(subject.select(&:frozen?)).to eql(subject)
       end
     end
   end
@@ -93,11 +93,11 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'freezes each key in the Hash' do
-      subject.keys.select(&:frozen?).should == subject.keys
+      expect(subject.keys.select(&:frozen?)).to eql(subject.keys)
     end
 
     it 'freezes each value in the Hash' do
-      subject.values.select(&:frozen?).should == subject.values
+      expect(subject.values.select(&:frozen?)).to eql(subject.values)
     end
 
     context 'with a circular reference' do
@@ -114,11 +114,11 @@ describe IceNine, '.deep_freeze' do
       end
 
       it 'freezes each key in the Hash' do
-        subject.keys.select(&:frozen?).should == subject.keys
+        expect(subject.keys.select(&:frozen?)).to eql(subject.keys)
       end
 
       it 'freezes each value in the Hash' do
-        subject.values.select(&:frozen?).should == subject.values
+        expect(subject.values.select(&:frozen?)).to eql(subject.values)
       end
     end
   end
@@ -135,11 +135,11 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'freeze the first object in the Range' do
-      subject.begin.should be_frozen
+      expect(subject.begin).to be_frozen
     end
 
     it 'freeze the last object in the Range' do
-      subject.end.should be_frozen
+      expect(subject.end).to be_frozen
     end
   end
 
@@ -159,7 +159,7 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'freezes the instance variables in the String' do
-      subject.instance_variable_get(:@a).should be_frozen
+      expect(subject.instance_variable_get(:@a)).to be_frozen
     end
 
     context 'with a circular reference' do
@@ -176,7 +176,7 @@ describe IceNine, '.deep_freeze' do
       end
 
       it 'freezes the instance variables in the String' do
-        subject.instance_variable_get(:@a).should be_frozen
+        expect(subject.instance_variable_get(:@a)).to be_frozen
       end
     end
   end
@@ -194,7 +194,7 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'freezes each value in the Struct' do
-      subject.values.select(&:frozen?).should == subject.values
+      expect(subject.values.select(&:frozen?)).to eql(subject.values)
     end
 
     context 'with a circular reference' do
@@ -211,7 +211,7 @@ describe IceNine, '.deep_freeze' do
       end
 
       it 'freezes each value in the Struct' do
-        subject.values.select(&:frozen?).should == subject.values
+        expect(subject.values.select(&:frozen?)).to eql(subject.values)
       end
     end
   end
@@ -232,7 +232,7 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'freezes the instance variables in the SimpleDelegator' do
-      subject.instance_variable_get(:@a).should be_frozen
+      expect(subject.instance_variable_get(:@a)).to be_frozen
     end
 
     context 'with a circular reference' do
@@ -249,7 +249,7 @@ describe IceNine, '.deep_freeze' do
       end
 
       it 'freezes the instance variables in the SimpleDelegator' do
-        subject.instance_variable_get(:@a).should be_frozen
+        expect(subject.instance_variable_get(:@a)).to be_frozen
       end
     end
   end

data/spec/spec_helper.rb

@@ -2,22 +2,29 @@
 
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
 
   SimpleCov.start do
-    command_name     'spec:unit'
-    add_filter       'config'
-    add_filter       'spec'
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'spec'
+    add_filter 'vendor'
+
     minimum_coverage 100
   end
 end
 
-require 'spec'
-require 'spec/autorun'
+require 'ice_nine'
+require 'devtools/spec_helper'
 
-# require spec support files and shared behavior
-Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
-  require file
-end
-
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
+  config.expect_with :rspec do |expect_with|
+    expect_with.syntax = :expect
+  end
 end

data/spec/unit/ice_nine/class_methods/deep_freeze_spec.rb

@@ -23,7 +23,7 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'freezes the instance variables in the Object' do
-      subject.instance_variable_get(:@a).should be_frozen
+      expect(subject.instance_variable_get(:@a)).to be_frozen
     end
   end
 
@@ -41,7 +41,7 @@ describe IceNine, '.deep_freeze' do
     end
 
     it 'does not freeze the instance variables in the Object' do
-      subject.instance_variable_get(:@a).should_not be_frozen
+      expect(subject.instance_variable_get(:@a)).to_not be_frozen
     end
   end
 end

data/spec/unit/ice_nine/freezer/array/class_methods/deep_freeze_spec.rb

@@ -20,7 +20,7 @@ describe IceNine::Freezer::Array, '.deep_freeze' do
     end
 
     it 'freezes each entry in the Array' do
-      subject.select(&:frozen?).should == subject
+      expect(subject.select(&:frozen?)).to eql(subject)
     end
   end
 end

data/spec/unit/ice_nine/freezer/class_methods/{element_reference_spec.rb → element_reader_spec.rb}

@@ -45,12 +45,12 @@ describe IceNine::Freezer, '.[]' do
       Object.send(:remove_const, :Application)
     end
 
-    before do
+    around do |example|
       namespace.const_set(:User, freezer)
       object.const_set(:Application, namespace)
-    end
 
-    after do
+      example.run
+
       namespace.send(:remove_const, :User)
       object.send(:remove_const, :Application)
     end
@@ -77,11 +77,62 @@ describe IceNine::Freezer, '.[]' do
     end
   end
 
-  describe 'when the module is anonymous' do
+  describe 'when the module is an anonymous class' do
     let(:mod) { Class.new }
 
     it 'returns the freezer' do
       should be(freezer)
     end
   end
+
+  describe 'when the module is an anonymous module' do
+    let(:mod) { Module.new }
+
+    it 'returns the freezer' do
+      should be_nil
+    end
+  end
+
+  describe 'when the module is under a freezer namespace' do
+    let(:mod)     { Hash::Test             }
+    let(:freezer) { IceNine::Freezer::Hash }
+
+    around do |example|
+      class Hash::Test; end
+      example.run
+      Hash.send(:remove_const, :Test)
+    end
+
+    it 'returns the freezer' do
+      should be(freezer)
+    end
+  end
+
+  describe 'when the module has a name of a freezer in another namespace' do
+    let(:mod)     { Mash::State                       }
+    let(:freezer) { Class.new(IceNine::Freezer::Hash) }
+
+    before :all do
+      module ::Mash
+        class State; end
+      end
+    end
+
+    after :all do
+      ::Mash.send(:remove_const, :State)
+      Object.send(:remove_const, :Mash)
+    end
+
+    around do |example|
+      object.const_set(:Mash, freezer)
+
+      example.run
+
+      object.send(:remove_const, :Mash)
+    end
+
+    it 'returns the freezer' do
+      should be(freezer)
+    end
+  end
 end

data/spec/unit/ice_nine/freezer/hash/class_methods/deep_freeze_spec.rb

@@ -22,24 +22,24 @@ describe IceNine::Freezer::Hash, '.deep_freeze' do
     end
 
     it 'freezes the default proc' do
-      subject.default_proc.should be_frozen
+      expect(subject.default_proc).to be_frozen
     end
 
     it 'freezes each key in the Hash' do
-      subject.keys.select(&:frozen?).should == subject.keys
+      expect(subject.keys.select(&:frozen?)).to eql(subject.keys)
     end
 
     it 'freezes each value in the Hash' do
-      subject.values.select(&:frozen?).should == subject.values
+      expect(subject.values.select(&:frozen?)).to eql(subject.values)
     end
 
-    if RUBY_VERSION >= '1.9' and RUBY_ENGINE == 'rbx'
+    if RUBY_VERSION >= '1.9' && RUBY_ENGINE == 'rbx'
       it 'does not freeze the Hash state' do
-        subject.instance_variable_get(:@state).should_not be_frozen
+        expect(subject.instance_variable_get(:@state)).to_not be_frozen
       end
 
       it 'does not freeze the Hash entries' do
-        subject.instance_variable_get(:@entries).should_not be_frozen
+        expect(subject.instance_variable_get(:@entries)).to_not be_frozen
       end
     end
   end
@@ -58,24 +58,24 @@ describe IceNine::Freezer::Hash, '.deep_freeze' do
     end
 
     it 'freezes the default value' do
-      subject.default.should be_frozen
+      expect(subject.default).to be_frozen
     end
 
     it 'freezes each key in the Hash' do
-      subject.keys.select(&:frozen?).should == subject.keys
+      expect(subject.keys.select(&:frozen?)).to eql(subject.keys)
     end
 
     it 'freezes each value in the Hash' do
-      subject.values.select(&:frozen?).should == subject.values
+      expect(subject.values.select(&:frozen?)).to eql(subject.values)
     end
 
-    if RUBY_VERSION >= '1.9' and RUBY_ENGINE == 'rbx'
+    if RUBY_VERSION >= '1.9' && RUBY_ENGINE == 'rbx'
       it 'does not freeze the Hash state' do
-        subject.instance_variable_get(:@state).should_not be_frozen
+        expect(subject.instance_variable_get(:@state)).to_not be_frozen
       end
 
       it 'does not freeze the Hash entries' do
-        subject.instance_variable_get(:@entries).should_not be_frozen
+        expect(subject.instance_variable_get(:@entries)).to_not be_frozen
       end
     end
   end

data/spec/unit/ice_nine/freezer/module/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer'
+require 'ice_nine/freezer/no_freeze'
+require 'ice_nine/freezer/module'
+
+describe IceNine::Freezer::Module, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with a Module object' do
+    let(:value) { Module.new }
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'does not freeze the object' do
+      expect { subject }.to_not change(value, :frozen?).from(false)
+    end
+  end
+end