ice_nine 0.10.0 → 0.11.0

data/lib/ice_nine/freezer/no_freeze.rb

@@ -13,14 +13,13 @@ module IceNine
       #   object.frozen?  # => false
       #
       # @param [Object] object
+      # @param [RecursionGuard] _recursion_guard
       #
       # @return [Object]
-      #
-      # @api public
-      def self.deep_freeze(object, *)
+      def self.guarded_deep_freeze(object, _recursion_guard)
         object
       end
 
-    end # class NoFreeze
-  end # class Freezer
-end # module IceNine
+    end # NoFreeze
+  end # Freezer
+end # IceNine

data/lib/ice_nine/freezer/numeric.rb

@@ -6,5 +6,5 @@ module IceNine
     # Skip freezing Numeric objects
     class Numeric < NoFreeze; end
 
-  end # class Freezer
-end # module IceNine
+  end # Freezer
+end # IceNine

data/lib/ice_nine/freezer/object.rb

@@ -15,11 +15,10 @@ module IceNine
       # @param [RecursionGuard] recursion_guard
       #
       # @return [Object]
-      #
-      # @api public
-      def self.deep_freeze(object, recursion_guard = RecursionGuard.new)
-        freeze_instance_variables(object, recursion_guard)
+      def self.guarded_deep_freeze(object, recursion_guard)
         object.freeze
+        freeze_instance_variables(object, recursion_guard)
+        object
       end
 
       # Handle freezing the object's instance variables
@@ -32,7 +31,7 @@ module IceNine
       # @api private
       def self.freeze_instance_variables(object, recursion_guard)
         object.instance_variables.each do |ivar_name|
-          IceNine.deep_freeze(
+          Freezer.guarded_deep_freeze(
             object.instance_variable_get(ivar_name),
             recursion_guard
           )
@@ -41,8 +40,8 @@ module IceNine
 
       private_class_method :freeze_instance_variables
 
-    end # class Object
+    end # Object
 
     BasicObject = Object
-  end # class Freezer
-end # module IceNine
+  end # Freezer
+end # IceNine

data/lib/ice_nine/freezer/range.rb

@@ -17,14 +17,13 @@ module IceNine
       # @param [RecursionGuard] recursion_guard
       #
       # @return [Range]
-      #
-      # @api public
-      def self.deep_freeze(range, recursion_guard = RecursionGuard.new)
-        IceNine.deep_freeze(range.begin, recursion_guard)
-        IceNine.deep_freeze(range.end, recursion_guard)
+      def self.guarded_deep_freeze(range, recursion_guard)
         super
+        Freezer.guarded_deep_freeze(range.begin, recursion_guard)
+        Freezer.guarded_deep_freeze(range.end, recursion_guard)
+        range
       end
 
-    end # class Range
-  end # class Freezer
-end # module IceNine
+    end # Range
+  end # Freezer
+end # IceNine

data/lib/ice_nine/freezer/rubinius.rb

@@ -6,5 +6,5 @@ module IceNine
     # Skip freezing Rubinius objects
     class Rubinius < NoFreeze; end
 
-  end # class Freezer
-end # module IceNine
+  end # Freezer
+end # IceNine

data/lib/ice_nine/freezer/struct.rb

@@ -6,5 +6,5 @@ module IceNine
     # A freezer class for handling Struct objects
     class Struct < Array; end
 
-  end # class Freezer
-end # module IceNine
+  end # Freezer
+end # IceNine

data/lib/ice_nine/freezer/symbol.rb

@@ -6,5 +6,5 @@ module IceNine
     # Skip freezing Symbol objects
     class Symbol < NoFreeze; end
 
-  end # class Freezer
-end # module IceNine
+  end # Freezer
+end # IceNine

data/lib/ice_nine/freezer/true_class.rb

@@ -6,5 +6,5 @@ module IceNine
     # Skip freezing true objects
     class TrueClass < NoFreeze; end
 
-  end # class Freezer
-end # module IceNine
+  end # Freezer
+end # IceNine

data/lib/ice_nine/support/recursion_guard.rb

@@ -3,35 +3,55 @@
 module IceNine
 
   # Protect against infinite recursion
+  #
+  # @private
   class RecursionGuard
 
-    # Initialize a recursion guard
-    #
-    # @return [undefined]
-    #
-    # @api public
-    def initialize
-      @object_ids = {}
-    end
-
-    # Guard against recursively calling a block with the same object
-    #
-    # @example
-    #   recursion_guard = IceNine::RecursionGuard.new
-    #   recursion_guard.guard(object_id) do
-    #     logic_which_may_be_recursively_called_with_object_id(recursion_guard)
-    #   end
-    #
-    # @param [Integer] caller_object_id
-    #
-    # @return [Object]
-    #
-    # @api public
-    def guard(caller_object_id)
-      return if @object_ids.key?(caller_object_id)
-      @object_ids[caller_object_id] = nil
-      yield
-    end
+    # Protects against infinite recursion by never yielding with the same
+    # object more than once.
+    class ObjectSet < self
+
+      # Initialize a recursion guard
+      #
+      # @return [undefined]
+      def initialize
+        @object_ids = {}
+      end
+
+      # Guard against recursively calling a block with the same object
+      #
+      # @example
+      #   recursion_guard = IceNine::RecursionGuard::ObjectSet.new
+      #   recursion_guard.guard(object) do
+      #     logic_which_may_be_recursively_called_with_object(recursion_guard)
+      #   end
+      #
+      # @param [Object] object
+      #
+      # @return [Object]
+      def guard(object)
+        caller_object_id = object.__id__
+        return object if @object_ids.key?(caller_object_id)
+        @object_ids[caller_object_id] = nil
+        yield
+      end
+
+    end # ObjectSet
+
+    # Protects against infinite recursion by not yielding with frozen objects
+    class Frozen < self
+
+      # Guard against recursively calling a block with the same frozen object
+      #
+      # @param [Object] object
+      #
+      # @return [Object]
+      def guard(object)
+        return object if object.frozen?
+        yield
+      end
+
+    end # Frozen
 
   end # RecursionGuard
-end # module IceNine
+end # IceNine

data/lib/ice_nine/version.rb

@@ -2,7 +2,7 @@
 
 module IceNine
 
-  # Unreleased gem version
-  VERSION = '0.10.0'.freeze
+  # Gem version
+  VERSION = '0.11.0'.freeze
 
-end # module IceNine
+end # IceNine

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine'
+require 'delegate'
+
+describe IceNine, '.deep_freeze!' do
+  subject { object.deep_freeze!(value) }
+
+  let(:object) { IceNine }
+
+  context 'with a shallowly frozen value' do
+    let(:value) { %w[a b].freeze }
+
+    it 'does not deep freeze' do
+      expect(subject.select(&:frozen?)).to be_empty
+    end
+  end
+
+  it_should_behave_like 'IceNine.deep_freeze'
+end

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

@@ -9,262 +9,13 @@ describe IceNine, '.deep_freeze' do
 
   let(:object) { IceNine }
 
-  context 'with an Object' do
-    let(:value) { Object.new }
+  context 'with a shallowly frozen value' do
+    let(:value) { ['a', %w[b c]].freeze }
 
-    before do
-      value.instance_eval { @a = '1' }
-    end
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.to change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes the instance variables in the Object' do
-      expect(subject.instance_variable_get(:@a)).to be_frozen
-    end
-
-    context 'with a circular reference' do
-      before do
-        value.instance_eval { @self = self }
-      end
-
-      it 'returns the object' do
-        should be(value)
-      end
-
-      it 'freezes the object' do
-        expect { subject }.to change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes the instance variables in the Object' do
-        expect(subject.instance_variable_get(:@a)).to be_frozen
-      end
+    it 'does a deep freeze' do
+      expect(subject.select(&:frozen?)).to eql(value)
     end
   end
 
-  context 'with an Array' do
-    let(:value) { %w[a] }
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.to change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes each element in the Array' do
-      expect(subject.select(&:frozen?)).to eql(subject)
-    end
-
-    context 'with a circular reference' do
-      before do
-        value << value
-      end
-
-      it 'returns the object' do
-        should be(value)
-      end
-
-      it 'freezes the object' do
-        expect { subject }.to change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes each element in the Array' do
-        expect(subject.select(&:frozen?)).to eql(subject)
-      end
-    end
-  end
-
-  context 'with a Hash' do
-    let(:value) { { Object.new => Object.new } }
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.to change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes each key in the Hash' do
-      expect(subject.keys.select(&:frozen?)).to eql(subject.keys)
-    end
-
-    it 'freezes each value in the Hash' do
-      expect(subject.values.select(&:frozen?)).to eql(subject.values)
-    end
-
-    context 'with a circular reference' do
-      before do
-        value[value] = value
-      end
-
-      it 'returns the object' do
-        should be(value)
-      end
-
-      it 'freezes the object' do
-        expect { subject }.to change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes each key in the Hash' do
-        expect(subject.keys.select(&:frozen?)).to eql(subject.keys)
-      end
-
-      it 'freezes each value in the Hash' do
-        expect(subject.values.select(&:frozen?)).to eql(subject.values)
-      end
-    end
-  end
-
-  context 'with a Range' do
-    let(:value) { 'a'..'z' }
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.to change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freeze the first object in the Range' do
-      expect(subject.begin).to be_frozen
-    end
-
-    it 'freeze the last object in the Range' do
-      expect(subject.end).to be_frozen
-    end
-  end
-
-  context 'with a String' do
-    let(:value) { '' }
-
-    before do
-      value.instance_eval { @a = '1' }
-    end
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.to change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes the instance variables in the String' do
-      expect(subject.instance_variable_get(:@a)).to be_frozen
-    end
-
-    context 'with a circular reference' do
-      before do
-        value.instance_eval { @self = self }
-      end
-
-      it 'returns the object' do
-        should be(value)
-      end
-
-      it 'freezes the object' do
-        expect { subject }.to change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes the instance variables in the String' do
-        expect(subject.instance_variable_get(:@a)).to be_frozen
-      end
-    end
-  end
-
-  context 'with a Struct' do
-    let(:value) { klass.new(%w[ 1 2 ]) }
-    let(:klass) { Struct.new(:a)       }
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.to change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes each value in the Struct' do
-      expect(subject.values.select(&:frozen?)).to eql(subject.values)
-    end
-
-    context 'with a circular reference' do
-      before do
-        value.a = value
-      end
-
-      it 'returns the object' do
-        should be(value)
-      end
-
-      it 'freezes the object' do
-        expect { subject }.to change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes each value in the Struct' do
-        expect(subject.values.select(&:frozen?)).to eql(subject.values)
-      end
-    end
-  end
-
-  context 'with an SimpleDelegator' do
-    let(:value) { SimpleDelegator.new(nil) }
-
-    before do
-      value.instance_eval { @a = '1' }
-    end
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.to change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes the instance variables in the SimpleDelegator' do
-      expect(subject.instance_variable_get(:@a)).to be_frozen
-    end
-
-    context 'with a circular reference' do
-      before do
-        value.instance_eval { @self = self }
-      end
-
-      it 'returns the object' do
-        should be(value)
-      end
-
-      it 'freezes the object' do
-        expect { subject }.to change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes the instance variables in the SimpleDelegator' do
-        expect(subject.instance_variable_get(:@a)).to be_frozen
-      end
-    end
-  end
-
-  [0.0, 0, 0x7fffffffffffffff, true, false, nil, :symbol].each do |value|
-    context "with a #{value.class}" do
-      let(:value) { value }
-
-      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
+  it_should_behave_like 'IceNine.deep_freeze'
 end