adamantium 0.0.2 → 0.0.3

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
-bundler_args: --without yard guard metrics
+bundler_args: --without yard guard
 script: "bundle exec rake spec"
 rvm:
   - 1.8.7

data/Gemfile

@@ -21,12 +21,17 @@ platform :jruby do
 end
 
 group :metrics do
-  gem 'flay',            '~> 1.4.2'
-  gem 'flog',            '~> 2.5.1'
-  gem 'reek',            '~> 1.2.8', :github => 'dkubb/reek'
-  gem 'roodi',           '~> 2.1.0'
-  gem 'yardstick',       '~> 0.7.0'
-  gem 'yard-spellcheck', '~> 0.1.5'
+  gem 'flay',      '~> 1.4.2'
+  gem 'flog',      '~> 2.5.1'
+  gem 'reek',      '~> 1.2.8', :github => 'dkubb/reek'
+  gem 'roodi',     '~> 2.1.0'
+  gem 'yardstick', '~> 0.7.0'
+  gem 'simplecov'
+
+  platforms :ruby_18, :ruby_19 do
+    # this indirectly depends on ffi which does not build on ruby-head
+    gem 'yard-spellcheck', '~> 0.1.5'
+  end
 
   platforms :mri_18 do
     gem 'arrayfields', '~> 4.7.4'  # for metric_fu

data/README.md

@@ -26,24 +26,95 @@ Examples
 require 'adamantium'
 require 'securerandom'
 
-class Foo
+class Example
+  # Inclusion of Adamantium defaults to deep freeze behavior
+  # of constructor and memoizer
+
   include Adamantium
 
-  def bar
-    SecureRandom.hex(6)
+  # Instance and attributes (ivars) are frozen per default
+  # Example:
+  #
+  # object = Example.new
+  # object.frozen?           # => true
+  # object.attribute.frozen? # => true
+  #
+  def initialize
+    @attribute = "foo bar"
   end
-
-  memoize :bar
+  attr_reader :attribute
+
+  # Memoized method with deeply frozen value (default)
+  # Example:
+  #
+  # object = Example.new
+  # object.random => ["abcdef"]
+  # object.random => ["abcdef"]
+  # object.random.frozen? => true
+  # object.random[0].frozen? => true
+  #
+  def random
+    [SecureRandom.hex(6)]
+  end
+  memoize :random
+
+  # Memoized method with non frozen value
+  # Example:
+  #
+  # object = Example.new
+  # object.buffer         # => <StringIO:abcdef>
+  # object.buffer         # => <StringIO:abcdef>
+  # object.buffer.frozen? # => false
+  #
+  def buffer
+    StringIO.new
+  end
+  memoize :buffer, :freezer => :noop
+
+  # Memoized method with nondeeply frozen value
+  # Example:
+  #
+  # object = Example.new
+  # object.random2 => ["abcdef"]
+  # object.random2 => ["abcdef"]
+  # object.random2.frozen? => true
+  # object.random2[0].frozen? => false
+  #
+  def random2
+    [SecureRandom.hex(6)]
+  end
+  memoize :random2, :freezer => :flat
 end
 
-object = Foo.new
-object.bar  # => "abcdef"
-# Value is memoized
-object.bar  # => "abcdef"
-# Returns the same object on all calls
-object.bar.equal?(object.bar)  # => true
-# Object is frozen
-object.frozen?  # => true
+class FlatExample
+  # Inclusion of Adamantium::Flat defaults do non deep frozen behavior
+  # for memoizer and constructor
+
+  include Adamantium::Flat
+
+  # Instace is frozen but attribute is not
+  # object = FlatExample.new
+  # object.frozen?           # => true
+  # object.attribute.frozen? # => false
+  def initialize
+    @attribute = "foo bar"
+  end
+  attr_reader :attribute
+
+  # Memoized method with flat frozen value (default)
+  # Example:
+  #
+  # object = Example.new
+  # object.random => ["abcdef"]
+  # object.random => ["abcdef"]
+  # object.random.frozen? => true
+  # object.random[0].frozen? => false
+  #
+  def random
+    [SecureRandom.hex(6)]
+  end
+  memoize :random
+end
 ```
 
 Credits
@@ -68,7 +139,7 @@ License
 -------
 
 Copyright (c) 2009-2012 Dan Kubb
-Copyright (c) 2012 Markus Schirp (packaging)
+Copyright (c) 2012 Markus Schirp
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 9
-total_score: 29
+total_score: 61

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 23.4
+threshold: 21.1

data/config/site.reek

@@ -46,7 +46,8 @@ UncommunicativeModuleName:
   - !ruby/regexp /[0-9]$/
 NestedIterators:
   ignore_iterators: []
-  exclude: []
+  exclude:
+  - Adamantium::ModuleMethods#define_memoize_method # 2 levels
   enabled: true
   max_allowed_nesting: 1
 LongMethod:

data/lib/adamantium.rb

@@ -6,6 +6,35 @@ module Adamantium
   # Storage for memoized methods
   Memory = Class.new(::Hash)
 
+  # Defaults to less strict defaults
+  module Flat
+
+    # Return flat freezer
+    #
+    # @return [Freezer::Flat]
+    #
+    # @api private
+    #
+    def freezer
+      Freezer::Flat
+    end
+
+    # Hook called when module is included
+    #
+    # @param [Class,Module] descendant
+    #
+    # @return [self]
+    #
+    # @api private
+    def self.included(descendant)
+      super
+      descendant.send(:include, Adamantium)
+      descendant.extend(self)
+
+      self
+    end
+  end
+
   # Hook called when module is included
   #
   # @param [Module] descendant
@@ -15,51 +44,11 @@ module Adamantium
   #
   # @api private
   def self.included(descendant)
-    super
     descendant.extend ModuleMethods if descendant.kind_of?(Module)
     descendant.extend ClassMethods  if descendant.kind_of?(Class)
     self
   end
 
-  # Attempt to freeze an object
-  #
-  # @example using a value object
-  #   Adamantium.freeze_object(12345)  # => noop
-  #
-  # @example using a normal object
-  #   Adamantium.freeze_object({})  # => duplicate & freeze object
-  #
-  # @param [Object] object
-  #   the object to freeze
-  #
-  # @return [Object]
-  #   if supported, the frozen object, otherwise the object directly
-  #
-  # @api public
-  def self.freeze_object(object)
-    case object
-    when Numeric, TrueClass, FalseClass, NilClass, Symbol
-      object
-    else
-      freeze_value(object)
-    end
-  end
-
-  # Returns a frozen value
-  #
-  # @param [Object] value
-  #   a value to freeze
-  #
-  # @return [Object]
-  #   if frozen, the value directly, otherwise a frozen copy of the value
-  #
-  # @api private
-  def self.freeze_value(value)
-    value.frozen? ? value : IceNine.deep_freeze(value.dup)
-  end
-
-  private_class_method :freeze_value
-
   # Freeze the object
   #
   # @example
@@ -102,7 +91,10 @@ module Adamantium
   #
   # @api public
   def memoize(name, value)
-    store_memory(name, value) unless memory.key?(name)
+    unless memory.key?(name)
+      store_memory(name, freeze_object(value))
+    end
+
     self
   end
 
@@ -129,6 +121,27 @@ private
     @__memory ||= Memory.new
   end
 
+  # Freeze object
+  #
+  # @param [Object] object
+  #   an object to be frozen
+  #
+  # @return [Object]
+  #
+  # @api private
+  def freeze_object(object)
+    freezer.call(object)
+  end
+
+  # Return class level freezer
+  #
+  # @return [#call]
+  #
+  # @api private
+  def freezer
+    self.class.freezer
+  end
+
   # Store the value in memory
   #
   # @param [Symbol] name
@@ -142,108 +155,10 @@ private
   #
   # @api private
   def store_memory(name, value)
-    memory[name] = Adamantium.freeze_object(value)
+    memory[name] = value
   end
-
-  # Methods mixed in to adamantium modules
-  module ModuleMethods
-
-    # Hook called when module is included
-    #
-    # @param [Module] mod
-    #   the module including ModuleMethods
-    #
-    # @return [self]
-    #
-    # @api private
-    def included(mod)
-      Adamantium.included(mod)
-      self
-    end
-
-    # Memoize a list of methods
-    #
-    # @example
-    #   memoize :hash
-    #
-    # @param [Array<#to_s>] methods
-    #   a list of methods to memoize
-    #
-    # @return [self]
-    #
-    # @api public
-    def memoize(*methods)
-      methods.each { |method| memoize_method(method) }
-      self
-    end
-
-  private
-
-    # Memoize the named method
-    #
-    # @param [#to_s] method
-    #   a method to memoize
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def memoize_method(method)
-      visibility = method_visibility(method)
-      define_memoize_method(method)
-      send(visibility, method)
-    end
-
-    # Define a memoized method that delegates to the original method
-    #
-    # @param [Symbol] method
-    #   the name of the method
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_memoize_method(method)
-      original = instance_method(method)
-      undef_method(method)
-      define_method(method) do |*args|
-        if memory.key?(method)
-          memoized(method)
-        else
-          store_memory(method, original.bind(self).call(*args))
-        end
-      end
-    end
-
-    # Return the method visibility of a method
-    #
-    # @param [String, Symbol] method
-    #   the name of the method
-    #
-    # @return [String]
-    #
-    # @api private
-    def method_visibility(method)
-      if    private_method_defined?(method)   then 'private'
-      elsif protected_method_defined?(method) then 'protected'
-      else                                         'public'
-      end
-    end
-
-  end # module ModuleMethods
-
-  # Methods mixed in to adamantium classes
-  module ClassMethods
-
-    # Instantiate a new frozen object
-    #
-    # @example
-    #   object = AdamantiumClass.new  # object is frozen
-    #
-    # @return [Object]
-    #
-    # @api public
-    def new(*)
-      IceNine.deep_freeze(super)
-    end
-
-  end # module ClassMethods
 end # module Adamantium
+
+require 'adamantium/module_methods'
+require 'adamantium/class_methods'
+require 'adamantium/freezer'

data/lib/adamantium/class_methods.rb

@@ -0,0 +1,20 @@
+module Adamantium
+
+  # Methods mixed in to adamantium classes
+  module ClassMethods
+
+    # Instantiate a new frozen object
+    #
+    # @example
+    #   object = AdamantiumClass.new  # object is frozen
+    #
+    # @return [Object]
+    #
+    # @api public
+    def new(*)
+      freezer.freeze(super)
+    end
+
+  end # module ClassMethods
+
+end

data/lib/adamantium/freezer.rb

@@ -0,0 +1,139 @@
+module Adamantium
+
+  # Abstract base class for freezers
+  #
+  # TODO: Use dkubb/abstract_class?
+  #
+  # Better pattern for singleton inheritance/shared code
+  class Freezer
+
+    private_class_method :new
+
+    # Attempt to freeze an object
+    #
+    # @example using a value object
+    #   Adamantium.freeze_object(12345)  # => noop
+    #
+    # @example using a normal object
+    #   Adamantium.freeze_object({})  # => duplicate & freeze object
+    #
+    # @param [Object] object
+    #   the object to freeze
+    #
+    # @return [Object]
+    #   if supported, the frozen object, otherwise the object directly
+    #
+    # @api public
+    def self.call(object)
+      case object
+      when Numeric, TrueClass, FalseClass, NilClass, Symbol, Class, Module
+        object
+      else
+        freeze_value(object)
+      end
+    end
+
+    private_class_method :call
+
+    # Returns a frozen value
+    #
+    # @param [Object] value
+    #   a value to freeze
+    #
+    # @return [Object]
+    #   if frozen, the value directly, otherwise a frozen copy of the value
+    #
+    # @api private
+    def self.freeze_value(value)
+      value.frozen? ? value : freeze(value.dup)
+    end
+
+    private_class_method :freeze_value
+
+    # Freezer that does not deep freeze
+    class Flat < self
+
+      # Freeze value
+      #
+      # @param [Object] value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def self.freeze(value)
+        value.freeze
+      end
+      public_class_method :call
+    end
+
+    # Freezer that does deep freeze
+    class Deep < self
+
+      # Deep freeze value
+      #
+      # @param [Object] value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def self.freeze(value)
+        IceNine.deep_freeze(value)
+      end
+      public_class_method :call
+    end
+
+    Noop = lambda { |object| object }.freeze
+
+    # Error raised when freezer cannot be found
+    class UnknownFreezerError < RuntimeError; end
+
+    # Error raised when memoizer options contain unknown keys
+    class OptionError < RuntimeError; end
+
+    # Return freezer for name
+    #
+    # @param [Symbol] name
+    #   a freezer name
+    #
+    # @return [#call]
+    #
+    # @api private
+    def self.get(name)
+      case name
+      when :noop
+        Noop
+      when :deep
+        Deep
+      when :flat
+        Flat
+      else
+        raise UnknownFreezerError, "Freezer with name #{name.inspect} is unknown"
+      end
+    end
+
+    # Parse freezer options
+    #
+    # @param [Hash] options
+    #   an options hash
+    #
+    # @return [#call]
+    #   if freezer option was present
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    def self.parse(options)
+      keys = options.keys - [:freezer]
+
+      unless keys.empty?
+        raise OptionError, "Unknown option key(s) for memoizer #{keys.inspect}"
+      end
+
+      return unless options.key?(:freezer)
+
+      get(options.fetch(:freezer))
+    end
+  end
+end

data/lib/adamantium/module_methods.rb

@@ -0,0 +1,103 @@
+module Adamantium
+
+  # Methods mixed in to adamantium modules
+  module ModuleMethods
+
+    # Hook called when module is included
+    #
+    # @param [Module] mod
+    #   the module including ModuleMethods
+    #
+    # @return [self]
+    #
+    # @api private
+    def included(mod)
+      Adamantium.included(mod)
+      self
+    end
+
+    # Return default deep freezer
+    #
+    # @return [Freezer::Deep]
+    #
+    # @api private
+    #
+    def freezer
+      Freezer::Deep
+    end
+
+    # Memoize a list of methods
+    #
+    # @example
+    #   memoize :hash
+    #
+    # @param [Array<#to_s>] methods
+    #   a list of methods to memoize
+    #
+    # @return [self]
+    #
+    # @api public
+    def memoize(*methods)
+      options        = methods.last.kind_of?(Hash) ? methods.pop : {}
+      method_freezer = Freezer.parse(options) || freezer
+      methods.each { |method| memoize_method(method, method_freezer) }
+      self
+    end
+
+  private
+
+    # Memoize the named method
+    #
+    # @param [#to_s] method
+    #   a method to memoize
+    # @param [#call] freezer
+    #   a freezer for memoized values
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def memoize_method(method, freezer)
+      visibility = method_visibility(method)
+      define_memoize_method(method, freezer)
+      send(visibility, method)
+    end
+
+    # Define a memoized method that delegates to the original method
+    #
+    # @param [Symbol] method
+    #   the name of the method
+    # @param [#call] freezer
+    #   a freezer for memoized values
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_memoize_method(method, freezer)
+      original = instance_method(method)
+      undef_method(method)
+      define_method(method) do |*args|
+        memory.fetch(method) do
+          value  = original.bind(self).call(*args)
+          frozen = freezer.call(value)
+          store_memory(method, frozen)
+        end
+      end
+    end
+
+    # Return the method visibility of a method
+    #
+    # @param [String, Symbol] method
+    #   the name of the method
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    def method_visibility(method)
+      if    private_method_defined?(method)   then :private
+      elsif protected_method_defined?(method) then :protected
+      else                                         :public
+      end
+    end
+
+  end # module ModuleMethods
+end # module Adamantium

data/lib/adamantium/version.rb

@@ -1,3 +1,3 @@
 module Adamantium
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.0.3'.freeze
 end

data/spec/integration/adamantium_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Adamantium do
+  let(:class_under_test) do
+    mixin = self.mixin
+
+    Class.new do
+      include mixin
+
+      def initialize
+        @attribute = Object.new
+      end
+      attr_reader :attribute
+
+      def memoized
+        [Object.new]
+      end
+      memoize :memoized
+    end
+  end
+
+  context 'inherited' do
+    let(:mixin) { Adamantium::Flat }
+
+    subject { Class.new(class_under_test).new }
+
+    it 'should return memoized value' do
+      subject.memoized
+    end
+  end
+
+  context 'default' do
+    let(:mixin) { Adamantium }
+
+    subject { class_under_test.new }
+
+    it 'should deep freeze instance and attributes' do
+      should be_frozen
+      subject.attribute.should be_frozen
+    end
+
+    it 'should deep freeze memoized values' do
+      subject.memoized.should be_frozen
+      subject.memoized[0].should be_frozen
+    end
+  end
+
+  context 'flat' do
+    let(:mixin) { Adamantium::Flat }
+
+    subject { class_under_test.new }
+
+    it 'should freeze only instance' do
+      should be_frozen
+      subject.attribute.should_not be_frozen
+    end
+
+    it 'should flat freeze memoized values' do
+      subject.memoized.should be_frozen
+      subject.memoized[0].should_not be_frozen
+    end
+  end
+end

data/spec/unit/adamantium/dup_spec.rb

@@ -7,7 +7,7 @@ describe Adamantium, '#dup' do
   subject { object.dup }
 
   let(:described_class) { AdamantiumSpecs::Object }
-  let(:object)          { described_class.new    }
+  let(:object)          { described_class.new     }
 
   it { should equal(object) }
 end

data/spec/unit/adamantium/flat/freezer_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Adamantium::ClassMethods, '#freezer' do
+  let(:object) do
+    Class.new do
+      include Adamantium::Flat
+    end
+  end
+
+  subject { object.freezer }
+
+  it { should be(Adamantium::Freezer::Flat) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/adamantium/freezer/class_methods/get_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Adamantium::Freezer, '.get' do
+  subject { object.get(name) }
+
+  let(:object) { described_class }
+
+  context 'with :deep' do
+    let(:name) { :deep }
+
+    it { should be(Adamantium::Freezer::Deep) }
+  end
+
+  context 'with :noop' do
+    let(:name) { :noop }
+
+    it { should be(Adamantium::Freezer::Noop) }
+  end
+
+  context 'with :flat' do
+    let(:name) { :flat }
+
+    it { should be(Adamantium::Freezer::Flat) }
+  end
+
+  context 'with unknown name' do
+    let(:name) { :other }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(described_class::UnknownFreezerError, 'Freezer with name :other is unknown')
+    end
+  end
+end

data/spec/unit/adamantium/freezer/class_methods/parse_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Adamantium::Freezer, '.parse' do
+  subject { object.parse(options) }
+
+  let(:object)  { described_class     }
+  let(:freezer) { mock('Freezer')     }
+
+  context 'with empty options' do
+    let(:options) { {}             }
+    it            { should be(nil) }
+  end
+
+  context 'with :freezer key' do
+    let(:options) { { :freezer => name } }
+    let(:name)    { mock('Name')         }
+
+    it 'should get freezer' do
+      described_class.should_receive(:get).with(name).and_return(freezer)
+      should be(freezer)
+    end
+  end
+
+  context 'with any other key' do
+    let(:options) { { :other => :key } }
+
+    it 'should raise error' do
+      expect { subject }.to raise_error(described_class::OptionError, 'Unknown option key(s) for memoizer [:other]')
+    end
+  end
+end

data/spec/unit/adamantium/freezer/deep/class_methods/call_spec.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adamantium::Freezer::Deep, '.call' do
+  subject { object.call(value) }
+
+  let(:object) { self.class.described_type }
+
+  context 'with a numeric value' do
+    let(:value) { 1 }
+
+    it { should equal(value) }
+  end
+
+  context 'with a true value' do
+    let(:value) { true }
+
+    it { should equal(value) }
+  end
+
+  context 'with a false value' do
+    let(:value) { false }
+
+    it { should equal(value) }
+  end
+
+  context 'with a nil value' do
+    let(:value) { nil }
+
+    it { should equal(value) }
+  end
+
+  context 'with a symbol value' do
+    let(:value) { :symbol }
+
+    it { should equal(value) }
+  end
+
+  context 'with a frozen value' do
+    let(:value) { String.new.freeze }
+
+    it { should equal(value) }
+  end
+
+  context 'with a module value' do
+    let(:value) { Module.new }
+
+    it { should equal(value) }
+
+    it { should_not be_frozen }
+  end
+
+  context 'with a class value' do
+    let(:value) { Class.new }
+
+    it { should equal(value) }
+
+    it { should_not be_frozen }
+  end
+
+  context 'with an unfrozen value' do
+    let(:value) { String.new }
+
+    it { should_not equal(value) }
+
+    it { should be_instance_of(String) }
+
+    it { should == value }
+
+    it { should be_frozen }
+  end
+
+  context 'with a composed value' do
+    let(:value) { [String.new] }
+
+    it 'does freeze inner values' do
+      subject.first.should be_frozen
+    end
+  end
+end

data/spec/unit/adamantium/freezer/deep/class_methods/freeze_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Adamantium::Freezer::Deep, '.freeze' do
+  subject { object.freeze(value) }
+
+  let(:object) { described_class }
+
+  let(:value) { mock('Value') }
+
+  it 'should deep freeze value' do
+    IceNine.should_receive(:deep_freeze).with(value).and_return(value)
+    should be(value)
+  end
+end

data/spec/unit/adamantium/{class_methods/freeze_object_spec.rb → freezer/flat/class_methods/call_spec.rb}

@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-describe Adamantium, '.freeze_object' do
-  subject { object.freeze_object(value) }
+describe Adamantium::Freezer::Flat, '.call' do
+  subject { object.call(value) }
 
   let(:object) { self.class.described_type }
 
@@ -54,4 +54,12 @@ describe Adamantium, '.freeze_object' do
 
     it { should be_frozen }
   end
+
+  context 'with a composed value' do
+    let(:value) { [String.new] }
+
+    it 'does NOT freeze inner values' do
+      subject.first.should_not be_frozen
+    end
+  end
 end

data/spec/unit/adamantium/freezer/flat/class_methods/freeze_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Adamantium::Freezer::Flat, '.freeze' do
+  subject { object.freeze(value) }
+
+  let(:object) { described_class }
+
+  let(:value) { mock('Value') }
+
+  it 'should freeze value' do
+    value.should_receive(:freeze).and_return(value)
+    should be(value)
+  end
+end

data/spec/unit/adamantium/memoize_spec.rb

@@ -7,8 +7,8 @@ describe Adamantium, '#memoize' do
   subject { object.memoize(method, value) }
 
   let(:described_class) { Class.new(AdamantiumSpecs::Object) }
-  let(:object)          { described_class.new               }
-  let(:method)          { :test                             }
+  let(:object)          { described_class.new                }
+  let(:method)          { :test                              }
 
   before do
     described_class.memoize(method)

data/spec/unit/adamantium/memoized_spec.rb

@@ -7,9 +7,9 @@ describe Adamantium, '#memoized' do
   subject { object.memoized(method) }
 
   let(:described_class) { Class.new(AdamantiumSpecs::Object) }
-  let(:method)          { :test                             }
-  let(:value)           { String.new.freeze                 }
-  let(:object)          { described_class.new               }
+  let(:method)          { :test                              }
+  let(:value)           { String.new.freeze                  }
+  let(:object)          { described_class.new                }
 
   before do
     described_class.memoize(method)

data/spec/unit/adamantium/module_methods/freezer_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Adamantium::ModuleMethods, '#freezer' do
+  let(:object) do
+    Class.new do
+      include Adamantium
+    end
+  end
+
+  subject { object.freezer }
+
+  it { should be(Adamantium::Freezer::Deep) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/adamantium/module_methods/memoize_spec.rb

@@ -10,19 +10,29 @@ shared_examples_for 'memoizes method' do
     instance.send(method).should equal(instance.send(method))
   end
 
-  it 'creates a method that returns a frozen value' do
+  it 'creates a method that returns a same value' do
     subject
-    object.new.send(method).should be_frozen
+    instance = object.new
+    first =  instance.send(method)
+    second = instance.send(method)
+    first.should be(second)
   end
 
   specification = proc do
     subject
-    file, line = object.new.send(method).first.split(':')[0, 2]
-    File.expand_path(file).should eql(File.expand_path('../../../../../lib/adamantium.rb', __FILE__))
-    line.to_i.should eql(211)
+    if method != :some_state
+      file, line = object.new.send(method).first.split(':')[0, 2]
+      File.expand_path(file).should eql(File.expand_path('../../../../../lib/adamantium/module_methods.rb', __FILE__))
+      line.to_i.should eql(80)
+    end
   end
 
   it 'sets the file and line number properly' do
+    # Exclude example for methot that does not return caller
+    if method == :some_method
+      return
+    end
+
     if RUBY_PLATFORM.include?('java')
       pending('Kernel#caller returns the incorrect line number in JRuby', &specification)
     else
@@ -49,9 +59,45 @@ shared_examples_for 'memoizes method' do
 end
 
 describe Adamantium::ModuleMethods, '#memoize' do
-  subject { object.memoize(method) }
+  subject { object.memoize(method, options) }
+  let(:options) { {} }
+
+  let(:object) do
+    Class.new(AdamantiumSpecs::Object) do
+      def some_state
+        Object.new
+      end
+    end
+  end
+
+  context 'with :noop freezer option' do
+    let(:method)  { :some_state       }
+    let(:options) { { :freezer => :noop } }
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'memoizes method'
+
+    it 'is still a public method' do
+      should be_public_method_defined(method)
+    end
+
+    it 'creates a method that returns a non frozen value' do
+      subject
+      object.new.send(method).should_not be_frozen
+    end
+  end
 
-  let(:object) { Class.new(AdamantiumSpecs::Object) }
+  context 'memoized method that returns generated values' do
+    let(:method) { :some_state }
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'memoizes method'
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      object.new.send(method).should be_frozen
+    end
+  end
 
   context 'public method' do
     let(:method) { :public_method }
@@ -62,6 +108,11 @@ describe Adamantium::ModuleMethods, '#memoize' do
     it 'is still a public method' do
       should be_public_method_defined(method)
     end
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      object.new.send(method).should be_frozen
+    end
   end
 
   context 'protected method' do
@@ -73,6 +124,11 @@ describe Adamantium::ModuleMethods, '#memoize' do
     it 'is still a protected method' do
       should be_protected_method_defined(method)
     end
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      object.new.send(method).should be_frozen
+    end
   end
 
   context 'private method' do
@@ -84,5 +140,10 @@ describe Adamantium::ModuleMethods, '#memoize' do
     it 'is still a private method' do
       should be_private_method_defined(method)
     end
+
+    it 'creates a method that returns a frozen value' do
+      subject
+      object.new.send(method).should be_frozen
+    end
   end
 end

data/tasks/metrics/ci.rake

@@ -5,5 +5,5 @@ task :ci => %w[ ci:metrics metrics:heckle ]
 
 namespace :ci do
   desc 'Run metrics (except heckle) and spec'
-  task :metrics => %w[ spec metrics:verify_measurements metrics:flog metrics:flay metrics:reek metrics:roodi ]
+  task :metrics => %w[ spec metrics:verify_measurements metrics:flog metrics:flay metrics:reek metrics:roodi metrics:all ]
 end

data/tasks/metrics/heckle.rake

@@ -47,7 +47,7 @@ begin
       map     = NameMap.new
 
       heckle_caught_modules = Hash.new { |hash, key| hash[key] = [] }
-      unhandled_mutations = 0
+      uncovered_methods = 0
 
       ObjectSpace.each_object(Module) do |mod|
         next unless mod.name =~ /\A#{root_module_regexp}(?::|\z)/
@@ -167,20 +167,19 @@ begin
               case line = line.chomp
                 when "The following mutations didn't cause test failures:"
                   heckle_caught_modules[mod.name] << method
-                when '+++ mutation'
-                  unhandled_mutations += 1
+                  uncovered_methods += 1
               end
             end
           end
         end
       end
 
-      if unhandled_mutations > 0
+      if uncovered_methods > 0
         error_message_lines = [ "*************\n" ]
 
-        error_message_lines << "Heckle found #{unhandled_mutations} " \
-          "mutation#{"s" unless unhandled_mutations == 1} " \
-          "that didn't cause spec violations\n"
+        error_message_lines << "Heckle found #{uncovered_methods} " \
+          "method#{"s" unless uncovered_methods == 1} " \
+          "where mutations didn't cause spec violations\n"
 
         heckle_caught_modules.each do |mod, methods|
           error_message_lines << "#{mod} contains the following " \
@@ -201,7 +200,9 @@ begin
     end
   end
 rescue LoadError
-  task :heckle => :coverage do
-    $stderr.puts 'Heckle or mspec is not available. In order to run heckle, you must: gem install heckle mspec'
+  namespace :metrics do
+    task :heckle => :coverage do
+      $stderr.puts 'Heckle or mspec is not available. In order to run heckle, you must: gem install heckle mspec'
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: adamantium
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Dan Kubb
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-26 00:00:00 Z
+date: 2012-11-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: backports
@@ -128,7 +128,11 @@ files:
 - config/site.reek
 - config/yardstick.yml
 - lib/adamantium.rb
+- lib/adamantium/class_methods.rb
+- lib/adamantium/freezer.rb
+- lib/adamantium/module_methods.rb
 - lib/adamantium/version.rb
+- spec/integration/adamantium_spec.rb
 - spec/rcov.opts
 - spec/shared/command_method_behavior.rb
 - spec/shared/each_method_behaviour.rb
@@ -138,13 +142,20 @@ files:
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/support/config_alias.rb
-- spec/unit/adamantium/class_methods/freeze_object_spec.rb
 - spec/unit/adamantium/class_methods/new_spec.rb
 - spec/unit/adamantium/dup_spec.rb
 - spec/unit/adamantium/fixtures/classes.rb
+- spec/unit/adamantium/flat/freezer_spec.rb
 - spec/unit/adamantium/freeze_spec.rb
+- spec/unit/adamantium/freezer/class_methods/get_spec.rb
+- spec/unit/adamantium/freezer/class_methods/parse_spec.rb
+- spec/unit/adamantium/freezer/deep/class_methods/call_spec.rb
+- spec/unit/adamantium/freezer/deep/class_methods/freeze_spec.rb
+- spec/unit/adamantium/freezer/flat/class_methods/call_spec.rb
+- spec/unit/adamantium/freezer/flat/class_methods/freeze_spec.rb
 - spec/unit/adamantium/memoize_spec.rb
 - spec/unit/adamantium/memoized_spec.rb
+- spec/unit/adamantium/module_methods/freezer_spec.rb
 - spec/unit/adamantium/module_methods/included_spec.rb
 - spec/unit/adamantium/module_methods/memoize_spec.rb
 - tasks/metrics/ci.rake
@@ -191,13 +202,21 @@ signing_key:
 specification_version: 3
 summary: Immutable extensions to objects
 test_files: 
-- spec/unit/adamantium/class_methods/freeze_object_spec.rb
+- spec/integration/adamantium_spec.rb
 - spec/unit/adamantium/class_methods/new_spec.rb
 - spec/unit/adamantium/dup_spec.rb
 - spec/unit/adamantium/fixtures/classes.rb
+- spec/unit/adamantium/flat/freezer_spec.rb
 - spec/unit/adamantium/freeze_spec.rb
+- spec/unit/adamantium/freezer/class_methods/get_spec.rb
+- spec/unit/adamantium/freezer/class_methods/parse_spec.rb
+- spec/unit/adamantium/freezer/deep/class_methods/call_spec.rb
+- spec/unit/adamantium/freezer/deep/class_methods/freeze_spec.rb
+- spec/unit/adamantium/freezer/flat/class_methods/call_spec.rb
+- spec/unit/adamantium/freezer/flat/class_methods/freeze_spec.rb
 - spec/unit/adamantium/memoize_spec.rb
 - spec/unit/adamantium/memoized_spec.rb
+- spec/unit/adamantium/module_methods/freezer_spec.rb
 - spec/unit/adamantium/module_methods/included_spec.rb
 - spec/unit/adamantium/module_methods/memoize_spec.rb
 has_rdoc: