ice_nine 0.2.0 → 0.3.0

data/Gemfile

@@ -23,7 +23,7 @@ group :metrics do
 
   platforms :mri_18, :rbx do
     gem 'heckle',    '~> 1.4.3'
-    gem 'json',      '~> 1.6.5'
+    gem 'json',      '~> 1.6.6'
     gem 'mspec',     '~> 1.5.17'
     gem 'ruby2ruby', '=  1.2.2'
   end

data/TODO

@@ -1,3 +0,0 @@
-* Move some of spec/unit/ice_nine/class_methods/deep_freeze_spec.rb into an
-  integration test.
-  * Keep some minimal unit tests just for the functionality in the method.

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 6
-total_score: 44.0
+total_score: 39.0

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 11.3
+threshold: 9.4

data/ice_nine.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |gem|
   gem.email       = [ 'dan.kubb@gmail.com' ]
   gem.description = 'Deep Freeze Ruby Objects'
   gem.summary     = gem.description
-  gem.homepage    = "https://github.com/dkubb/ice_nine"
+  gem.homepage    = 'https://github.com/dkubb/ice_nine'
 
   gem.require_paths    = %w[ lib ]
   gem.files            = `git ls-files`.split("\n")

data/lib/ice_nine/freezer/enumerable.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Enumerable objects
+    class Enumerable < Object
+
+      # Deep Freeze an Enumerable
+      #
+      # @example
+      #   enumerable = IceNine:Freezer::Enumerable.deep_freeze(%w[a b c])
+      #   enumerable.select(&:frozen?)  # => ['a', 'b', 'c']
+      #
+      # @param [Enumerable] enumerable
+      #
+      # @return [Enumerable]
+      #
+      # @todo use super on #each when Struct#each returns self in Rubinius
+      #
+      # @api public
+      def self.deep_freeze(enumerable)
+        enumerable.each { |entry| IceNine.deep_freeze(entry) }
+        super enumerable
+      end
+
+    end # class Enumerable
+  end # class Freezer
+end # module IceNine

data/lib/ice_nine/freezer/false_class.rb

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

data/lib/ice_nine/freezer/hash/state.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+    class Hash
+
+      # Skip freezing Hash::State objects on Rubinius
+      class State < NoFreeze; end
+
+    end # class Hash
+  end # class Freezer
+end # module IceNine

data/lib/ice_nine/freezer/nil_class.rb

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

data/lib/ice_nine/freezer/no_freeze.rb

@@ -22,27 +22,5 @@ module IceNine
       end
 
     end # class NoFreeze
-
-    # Skip freezing nil objects
-    class NilClass < NoFreeze; end
-
-    # Skip freezing true objects
-    class TrueClass < NoFreeze; end
-
-    # Skip freezing false objects
-    class FalseClass < NoFreeze; end
-
-    # Skip freezing Symbol objects
-    class Symbol < NoFreeze; end
-
-    # Skip freezing Numeric objects
-    class Numeric < NoFreeze; end
-
-    # Skip freezing Rubinius objects
-    class Rubinius < NoFreeze; end
-
-    # Skip freezing Hash::State objects on Rubinius
-    class Hash::State < NoFreeze; end
-
   end # class Freezer
 end # module IceNine

data/lib/ice_nine/freezer/numeric.rb

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

data/lib/ice_nine/freezer/rubinius.rb

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

data/lib/ice_nine/freezer/string.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling String objects
+    class String < Object; end
+
+  end # class Freezer
+end # module IceNine

data/lib/ice_nine/freezer/struct.rb

@@ -4,26 +4,7 @@ module IceNine
   class Freezer
 
     # A freezer class for handling Struct objects
-    class Struct < Object
+    class Struct < Enumerable; end
 
-      # Deep Freeze a Struct
-      #
-      # @example
-      #   struct = IceNine:Freezer::Struct.deep_freeze(klass.new('1'))
-      #   struct.values.select(&:frozen?)  # => ['1']
-      #
-      # @param [Struct] struct
-      #
-      # @return [Struct]
-      #
-      # @todo use super on Struct#each once it returns self in Rubinius
-      #
-      # @api public
-      def self.deep_freeze(struct)
-        struct.each(&IceNine.method(:deep_freeze))
-        super struct
-      end
-
-    end # class Struct
   end # class Freezer
 end # module IceNine

data/lib/ice_nine/freezer/symbol.rb

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

data/lib/ice_nine/freezer/true_class.rb

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

data/lib/ice_nine/version.rb

@@ -1,5 +1,8 @@
 # encoding: utf-8
 
 module IceNine
-  VERSION = '0.2.0'
-end
+
+  # Current gem version
+  VERSION = '0.3.0'
+
+end # module IceNine

data/lib/ice_nine.rb

@@ -6,13 +6,20 @@ require 'ice_nine/support/recursion_guard'
 
 require 'ice_nine/freezer'
 require 'ice_nine/freezer/object'
+require 'ice_nine/freezer/no_freeze'
+require 'ice_nine/freezer/enumerable'
 
-require 'ice_nine/freezer/array'
+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/numeric'
 require 'ice_nine/freezer/range'
+require 'ice_nine/freezer/rubinius'
+require 'ice_nine/freezer/string'
 require 'ice_nine/freezer/struct'
-
-require 'ice_nine/freezer/no_freeze'
+require 'ice_nine/freezer/symbol'
+require 'ice_nine/freezer/true_class'
 
 require 'ice_nine/version'
 

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

@@ -0,0 +1,193 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine'
+
+describe IceNine, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { IceNine }
+
+  context 'with an Object' do
+    let(:value) { Object.new }
+
+    before do
+      value.instance_eval { @a = '1' }
+    end
+
+    it 'returns the object' do
+      should be(value)
+    end
+
+    it 'freezes the object' do
+      expect { subject }.should change(value, :frozen?).from(false).to(true)
+    end
+
+    it 'freezes the instance variables in the Object' do
+      subject.instance_variable_get(:@a).should 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 }.should change(value, :frozen?).from(false).to(true)
+      end
+
+      it 'freezes the instance variables in the Object' do
+        subject.instance_variable_get(:@a).should be_frozen
+      end
+    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 }.should change(value, :frozen?).from(false).to(true)
+    end
+
+    it 'freezes each element in the Array' do
+      subject.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
+      end
+
+      it 'freezes each element in the Array' do
+        subject.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
+    end
+
+    it 'freezes each key in the Hash' do
+      subject.keys.select(&:frozen?).should == subject.keys
+    end
+
+    it 'freezes each value in the Hash' do
+      subject.values.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
+      end
+
+      it 'freezes each key in the Hash' do
+        subject.keys.select(&:frozen?).should == subject.keys
+      end
+
+      it 'freezes each value in the Hash' do
+        subject.values.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
+    end
+
+    it 'freeze the first object in the Range' do
+      subject.begin.should be_frozen
+    end
+
+    it 'freeze the last object in the Range' do
+      subject.end.should be_frozen
+    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 }.should change(value, :frozen?).from(false).to(true)
+    end
+
+    it 'freezes each value in the Struct' do
+      subject.values.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
+      end
+
+      it 'freezes each value in the Struct' do
+        subject.values.select(&:frozen?).should == subject.values
+      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 }.should_not change(value, :frozen?).from(false)
+      end
+    end
+  end
+end

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

@@ -6,188 +6,22 @@ require 'ice_nine'
 describe IceNine, '.deep_freeze' do
   subject { object.deep_freeze(value) }
 
-  let(:object) { IceNine }
+  let(:object) { IceNine    }
+  let(:value)  { Object.new }
 
-  context 'with an Object' do
-    let(:value) { Object.new }
-
-    before do
-      value.instance_eval { @a = '1' }
-    end
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.should change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes the instance variables in the Object' do
-      subject.instance_variable_get(:@a).should 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 }.should change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes the instance variables in the Object' do
-        subject.instance_variable_get(:@a).should be_frozen
-      end
-    end
+  before do
+    value.instance_eval { @a = '1' }
   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 }.should change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes each element in the Array' do
-      subject.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes each element in the Array' do
-        subject.select(&:frozen?).should == subject
-      end
-    end
+  it 'returns the object' do
+    should be(value)
   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 }.should change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes each key in the Hash' do
-      subject.keys.select(&:frozen?).should == subject.keys
-    end
-
-    it 'freezes each value in the Hash' do
-      subject.values.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes each key in the Hash' do
-        subject.keys.select(&:frozen?).should == subject.keys
-      end
-
-      it 'freezes each value in the Hash' do
-        subject.values.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freeze the first object in the Range' do
-      subject.begin.should be_frozen
-    end
-
-    it 'freeze the last object in the Range' do
-      subject.end.should be_frozen
-    end
-  end
-
-  context 'with a Struct' do
-    let(:value) { klass.new('1') }
-    let(:klass) { Struct.new(:a) }
-
-    it 'returns the object' do
-      should be(value)
-    end
-
-    it 'freezes the object' do
-      expect { subject }.should change(value, :frozen?).from(false).to(true)
-    end
-
-    it 'freezes each value in the Struct' do
-      subject.values.select(&:frozen?).should == 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 }.should change(value, :frozen?).from(false).to(true)
-      end
-
-      it 'freezes each value in the Struct' do
-        subject.values.select(&:frozen?).should == subject.values
-      end
-    end
+  it 'freezes the object' do
+    expect { subject }.should change(value, :frozen?).from(false).to(true)
   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 }.should_not change(value, :frozen?).from(false)
-      end
-    end
+  it 'freezes the instance variables in the Object' do
+    subject.instance_variable_get(:@a).should be_frozen
   end
 end

data/spec/unit/ice_nine/freezer/class_methods/element_reference_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 require 'ice_nine/freezer'
-require 'ice_nine/freezer/struct'
+require 'ice_nine/freezer/enumerable'
 
 describe IceNine::Freezer, '.[]' do
   subject { object[mod] }

data/spec/unit/ice_nine/freezer/{array → enumerable}/class_methods/deep_freeze_spec.rb

@@ -2,14 +2,14 @@
 
 require 'spec_helper'
 require 'ice_nine/freezer'
-require 'ice_nine/freezer/array'
+require 'ice_nine/freezer/enumerable'
 
-describe IceNine::Freezer::Array, '.deep_freeze' do
+describe IceNine::Freezer::Enumerable, '.deep_freeze' do
   subject { object.deep_freeze(value) }
 
   let(:object) { described_class }
 
-  context 'with an Array object' do
+  context 'with an Enumerable object' do
     let(:value) { %w[a] }
 
     it 'returns the object' do
@@ -20,7 +20,7 @@ describe IceNine::Freezer::Array, '.deep_freeze' do
       expect { subject }.should change(value, :frozen?).from(false).to(true)
     end
 
-    it 'freezes each element in the Array' do
+    it 'freezes each entry in the Enumerable' do
       subject.select(&:frozen?).should == subject
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ice_nine
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Dan Kubb
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-27 00:00:00 Z
+date: 2012-03-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
@@ -81,20 +81,29 @@ files:
 - lib/ice_nine.rb
 - lib/ice_nine/core_ext/object.rb
 - lib/ice_nine/freezer.rb
-- lib/ice_nine/freezer/array.rb
+- lib/ice_nine/freezer/enumerable.rb
+- lib/ice_nine/freezer/false_class.rb
 - lib/ice_nine/freezer/hash.rb
+- lib/ice_nine/freezer/hash/state.rb
+- lib/ice_nine/freezer/nil_class.rb
 - lib/ice_nine/freezer/no_freeze.rb
+- lib/ice_nine/freezer/numeric.rb
 - lib/ice_nine/freezer/object.rb
 - lib/ice_nine/freezer/range.rb
+- lib/ice_nine/freezer/rubinius.rb
+- lib/ice_nine/freezer/string.rb
 - lib/ice_nine/freezer/struct.rb
+- lib/ice_nine/freezer/symbol.rb
+- lib/ice_nine/freezer/true_class.rb
 - lib/ice_nine/support/recursion_guard.rb
 - lib/ice_nine/version.rb
+- spec/integration/ice_nine/class_methods/deep_freeze_spec.rb
 - spec/rcov.opts
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/unit/ice_nine/class_methods/deep_freeze_spec.rb
-- spec/unit/ice_nine/freezer/array/class_methods/deep_freeze_spec.rb
 - spec/unit/ice_nine/freezer/class_methods/element_reference_spec.rb
+- spec/unit/ice_nine/freezer/enumerable/class_methods/deep_freeze_spec.rb
 - spec/unit/ice_nine/freezer/false_class/class_methods/deep_freeze_spec.rb
 - spec/unit/ice_nine/freezer/hash/class_methods/deep_freeze_spec.rb
 - spec/unit/ice_nine/freezer/nil_class/class_methods/deep_freeze_spec.rb

data/lib/ice_nine/freezer/array.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-module IceNine
-  class Freezer
-
-    # A freezer class for handling Array objects
-    class Array < Object
-
-      # Deep Freeze an Array
-      #
-      # @example
-      #   array = IceNine:Freezer::Array.deep_freeze(%w[a b c])
-      #   array.select(&:frozen?)  # => ['a', 'b', 'c']
-      #
-      # @param [Array] array
-      #
-      # @return [Array]
-      #
-      # @api public
-      def self.deep_freeze(array)
-        super array.each(&:freeze)
-      end
-
-    end # class Array
-  end # class Freezer
-end # module IceNine