ice_nine 0.1.0

data/lib/ice_nine/freezer/array.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Array objects
+    class Array < self
+
+      # 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

data/lib/ice_nine/freezer/hash.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Hash objects
+    class Hash < self
+
+      # Deep Freeze a Hash
+      #
+      # @example
+      #   hash = IceNine::Freezer::Hash.deep_freeze('a' => '1', 'b' => '2')
+      #   hash.keys.select(&:frozen?)    # => [ 'a', 'b' ]
+      #   hash.values.select(&:frozen?)  # => [ '1', '2' ]
+      #
+      # @param [Hash] hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def self.deep_freeze(hash)
+        super hash.each { |key, value|
+          IceNine.deep_freeze(key)
+          IceNine.deep_freeze(value)
+        }
+      end
+
+    end # class Hash
+  end # class Freezer
+end # module IceNine

data/lib/ice_nine/freezer/no_freeze.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class that does not freeze anything
+    class NoFreeze < self
+
+      # Pass through the object without freezing it
+      #
+      # @example
+      #   object = IceNine::Freezer::NoFreeze.deep_freeze(object)
+      #   object.frozen?  # => false
+      #
+      # @param [Object] object
+      #
+      # @return [Object]
+      #
+      # @api public
+      def self.deep_freeze(object)
+        object
+      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/range.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Range objects
+    class Range < self
+
+      # Deep Freeze a Range
+      #
+      # @example
+      #   range = IceNine:Freezer::Range.deep_freeze('a'..'z')
+      #   range.begin.frozen?  # => true
+      #   range.end.frozen?    # => true
+      #
+      # @param [Range] range
+      #
+      # @return [Range]
+      #
+      # @api public
+      def self.deep_freeze(range)
+        IceNine.deep_freeze(range.begin)
+        IceNine.deep_freeze(range.end)
+        super range
+      end
+
+    end # class Range
+  end # class Freezer
+end # module IceNine

data/lib/ice_nine/freezer/struct.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module IceNine
+  class Freezer
+
+    # A freezer class for handling Struct objects
+    class Struct < self
+
+      # 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 rbx
+      #
+      # @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/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module IceNine
+  VERSION = '0.1.0'
+end

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--loadby random
+--format profile

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'rspec'  # try for RSpec 2
+rescue LoadError
+  require 'spec'   # try for RSpec 1
+  RSpec = Spec::Runner
+end
+
+# require spec support files and shared behavior
+Dir[File.expand_path('../shared/**/*.rb', __FILE__)].each { |file| require file }
+
+RSpec.configure do |config|
+end
+
+# change the heckle timeout to be 5 seconds
+if defined?(::Heckle)
+  class ::Heckle
+    @@timeout = 5
+  end
+end

data/spec/unit/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) { self.class.described_type }
+
+  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('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
+  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/freezer/array/class_methods/deep_freeze_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine/freezer'
+require 'ice_nine/freezer/array'
+
+describe IceNine::Freezer::Array, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  context 'with an Array object' 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
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine'
+
+describe IceNine::Freezer, '.deep_freeze' do
+  subject { object.deep_freeze(value) }
+
+  let(:object) { described_class }
+
+  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
+  end
+end