ice_nine 0.10.0 → 0.11.0

data/spec/shared/array_deep_freeze_shared_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+shared_examples 'IceNine::Freezer::Array.deep_freeze' do
+  it_behaves_like 'IceNine::Freezer::Object.deep_freeze'
+
+  it 'freezes each entry' do
+    expect(subject.select(&:frozen?)).to eql(subject.to_a)
+  end
+end

data/spec/shared/hash_deep_freeze_shared_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+shared_examples 'IceNine::Freezer::Hash.deep_freeze' do
+  it_behaves_like 'IceNine::Freezer::Object.deep_freeze'
+
+  it 'freezes each key' do
+    expect(subject.keys.select(&:frozen?)).to eql(subject.keys)
+  end
+
+  it 'freezes each value' do
+    expect(subject.values.select(&:frozen?)).to eql(subject.values)
+  end
+
+  if RUBY_VERSION >= '1.9' && RUBY_ENGINE == 'rbx'
+    it 'does not freeze the state' do
+      expect(subject.instance_variable_get(:@state)).to_not be_frozen
+    end
+
+    it 'does not freeze the entries' do
+      expect(subject.instance_variable_get(:@entries)).to_not be_frozen
+    end
+  end
+end

data/spec/shared/ice_nine_deep_freeze_shared_spec.rb

@@ -0,0 +1,263 @@
+# encoding: utf-8
+
+shared_examples 'IceNine.deep_freeze' do
+
+  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 }.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
+    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
+end

data/spec/shared/no_freeze_deep_freeze_shared_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+shared_examples 'IceNine::Freezer::NoFreeze.deep_freeze' do
+  before do
+    value.instance_eval { @a = '1' } unless value.frozen?
+  end
+
+  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
+
+  it 'does not freeze instance variables' do
+    expect(subject.instance_variable_get(:@a)).to_not be_frozen
+  end
+end

data/spec/shared/object_deep_freeze_shared_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+shared_examples 'IceNine::Freezer::Object.deep_freeze' do
+  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 instance variables' do
+    expect(subject.instance_variable_get(:@a)).to be_frozen
+  end
+end

data/spec/shared/range_deep_freeze_shared_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+shared_examples 'IceNine::Freezer::Range.deep_freeze' do
+  it_behaves_like 'IceNine::Freezer::Object.deep_freeze'
+
+  it 'freeze the first element' do
+    expect(subject.begin).to be_frozen
+  end
+
+  it 'freeze the last element' do
+    expect(subject.end).to be_frozen
+  end
+end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine'
+
+describe IceNine, '.deep_freeze!' do
+  subject { object.deep_freeze!(value) }
+
+  let(:object) { IceNine    }
+  let(:value)  { Object.new }
+
+  context 'when the object is not frozen' do
+    it_behaves_like 'IceNine::Freezer::Object.deep_freeze'
+  end
+
+  context 'when the object is frozen' do
+    before do
+      value.instance_eval { @a = '1' }
+      value.freeze
+    end
+
+    it_behaves_like 'IceNine::Freezer::NoFreeze.deep_freeze'
+  end
+end

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

@@ -9,26 +9,13 @@ describe IceNine, '.deep_freeze' do
   let(:object) { IceNine    }
   let(:value)  { Object.new }
 
-  before do
-    value.instance_eval { @a = '1' }
-  end
-
   context 'when the object is not frozen' do
-    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_behaves_like 'IceNine::Freezer::Object.deep_freeze'
   end
 
   context 'when the object is frozen' do
     before do
+      value.instance_eval { @a = '1' }
       value.freeze
     end
 
@@ -36,12 +23,12 @@ describe IceNine, '.deep_freeze' do
       should be(value)
     end
 
-    it 'does not freeze the object' do
-      expect { subject }.to_not change(value, :frozen?).from(true)
+    it 'leaves the object frozen' do
+      expect { subject }.not_to change(value, :frozen?).from(true)
     end
 
-    it 'does not freeze the instance variables in the Object' do
-      expect(subject.instance_variable_get(:@a)).to_not be_frozen
+    it 'freezes instance variables' do
+      expect(subject.instance_variable_get(:@a)).to be_frozen
     end
   end
 end

data/spec/unit/ice_nine/core_ext/object/deep_freeze_bang_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'ice_nine'
+require 'ice_nine/core_ext/object'
+
+describe IceNine::CoreExt::Object, '#deep_freeze!' do
+  subject { value.deep_freeze! }
+
+  let(:value) { Object.new.extend(IceNine::CoreExt::Object) }
+
+  context 'when the object is not frozen' do
+    it_behaves_like 'IceNine::Freezer::Object.deep_freeze'
+  end
+
+  context 'when the object is frozen' do
+    before do
+      value.instance_eval { @a = '1' }
+      value.freeze
+    end
+
+    it_behaves_like 'IceNine::Freezer::NoFreeze.deep_freeze'
+  end
+end