virtus 0.0.5 → 0.0.6

data/.travis.yml

@@ -1,6 +1,13 @@
-script: "bundle exec rspec spec/"
+bundler_args: --without guard metrics
+script: "bundle exec rake spec"
 rvm:
   - 1.8.7
   - 1.9.2
-  - jruby
   - rbx
+  - rbx-2.0
+  - ree
+  - jruby
+  - ruby-head
+notifications:
+  email:
+    - piotr.solnica@gmail.com

data/.yardopts

@@ -0,0 +1 @@
+- README.md History.md LICENSE

data/History.md

@@ -0,0 +1,51 @@
+# v0.0.6 to-be-released
+
+* [BREAKING CHANGE] Moved Virtus.determine_type to a shared module Virtus::TypeLookup (dkubb)
+* [BREAKING CHANGE] Attribute#typecast_to_primitive has been replaced by Attribute#coerce (solnic)
+* [BREAKING CHANGE] Attribute#typecast logic was moved to Attribute#set which is now a public method (solnic)
+* [feature] Added support for default values (solnic)
+* [general] Added custom inspect for Attribute classes (solnic)
+* [general] Added backports as a development dependency (dkubb)
+* [changed] Options API has been extracted from Attribute to a support module Virtus::Options (solnic)
+* [changed] Typecast classes have been replace by a new hierarchy of Coercion classes like Coercion::String, Coercion::Integer etc. (solnic)
+* [changed] Attribute#get, #get!, #set, #set! & #coerce are now part of the public API (solnic)
+
+[Compare v0.0.5..master](https://github.com/solnic/virtus/compare/v0.0.5...master)
+
+# v0.0.5 2011-07-10
+
+* [bugfix] Fixed DescendantsTracker + ActiveSupport collision (dkubb)
+
+[Compare v0.0.4..v0.0.5](https://github.com/solnic/virtus/compare/v0.0.4...v0.0.5)
+
+# v0.0.4 2011-07-08
+
+* [BREAKING CHANGE] attributes hash has been replaced by a specialized class AttributeSet (dkubb)
+* [BREAKING CHANGE] Virtus::ClassMethods.attribute returns self instead of a created attribute (solnic)
+* [changed] descendants tracking has been extracted into DescendantsTracker module (dkubb)
+* [changed] Instance #primitive? method has been replaced by class utility method Virtus::Attribute.primitive? (solnic)
+* [changed] Virtus::Attribute::String#typecast_to_primitive delegates to Virtus::Typecast::String.call (solnic)
+
+[Compare v0.0.3..v0.0.4](https://github.com/solnic/virtus/compare/v0.0.3...v0.0.4)
+
+# v0.0.3 2011-06-09
+
+* [BREAKING CHANGE] Attribute classes were moved to Virtus::Attribute namespace (solnic)
+* [BREAKING CHANGE] Attribute instance no longer holds the reference to a model (solnic)
+* [BREAKING CHANGE] #typecast no longer receives an instance of a model (override #set which calls #typecast if you need that) (solnic)
+* [changed] Adding reader/writer methods was moved from the attribute constructor to Virtus::ClassMethods.attribute (solnic)
+* [changed] Typecast logic has been moved into separate classes (see Virtus::Typecast) (solnic)
+* [added] Virtus::Attribute::DateTime#typecast supports objects which implement #to_datetime (solnic)
+* [general] Internals have been cleaned up, simplified and properly documented (solnic)
+
+[Compare v0.0.2..v0.0.3](https://github.com/solnic/virtus/compare/v0.0.2...v0.0.3)
+
+# v0.0.2 2011-06-06
+
+* [bugfix] Fixed #typecast in custom attribute classes (solnic)
+
+[Compare v0.0.1..v0.0.2](https://github.com/solnic/virtus/compare/v0.0.1...v0.0.2)
+
+# v0.0.1 2011-06-04
+
+First public release :)

data/{README.markdown → README.md}

@@ -2,11 +2,11 @@
 
 This is a partial extraction of the DataMapper [Property
 API](http://rubydoc.info/github/datamapper/dm-core/master/DataMapper/Property)
-with various modifications. My goal is to provide a common API to define
-attributes on a model along with (auto-)validations so all ORMs/ODMs could use
-it instead of reinventing the wheel all over again. It would be also suitable
-for any other usecase where you need to extend your ruby objects with various
-attributes that require typecasting and/or validations.
+with various modifications and improvements. The goal is to provide a common API
+for defining attributes on a model so all ORMs/ODMs could use it instead of
+reinventing the wheel all over again. It is also suitable for any other
+usecase where you need to extend your ruby objects with attributes that require
+data type coercions.
 
 ## Installation
 
@@ -33,13 +33,63 @@ attributes that require typecasting and/or validations.
     # hash of attributes
     user.attributes  # => { :name => "Piotr" }
 
-    # automatic typecasting
+    # automatic coercion
     user.age = '28'
     user.age  # => 28
 
     user.birthday = 'November 18th, 1983'
     user.birthday  # => #<DateTime: 1983-11-18T00:00:00+00:00 (4891313/2,0/1,2299161)>
 
+## Default values
+
+    require 'virtus'
+
+    class Page
+      include Virtus
+
+      attribute :title,      String
+      attribute :slug,       String,  :default => lambda { |post, attribute| post.title.downcase.gsub(' ', '-') }
+      attribute :view_count, Integer, :default => 0
+    end
+
+    page = Page.new(:title => 'Virtus Is Awesome')
+    page.slug # => 'virtus-is-awesome'
+    page.view_count # => 0
+
+## Coercions
+
+Virtus comes with a builtin coercion library. It's super easy to add your own
+coercion classes. Take a look:
+
+    require 'virtus'
+    require 'digest/md5'
+
+    class MD5 < Virtus::Attribute::Object
+     primitive       String
+     coercion_method :to_md5
+    end
+
+    module Virtus
+     class Coercion
+       class String < Virtus::Coercion::Object
+         def self.to_md5(value)
+           Digest::MD5.hexdigest(value)
+         end
+       end
+     end
+    end
+
+    class User
+      include Virtus
+
+      attribute :name,     String
+      attribute :password, MD5
+    end
+
+    user = User.new(:name => 'Piotr', :password => 'foobar')
+    user.name     # => 'Piotr'
+    user.password # => '3858f62230ac3c915f300c664312c63f'
+
 ## Custom Attributes
 
     require 'virtus'
@@ -50,7 +100,7 @@ attributes that require typecasting and/or validations.
         class JSON < Virtus::Attribute::Object
           primitive Hash
 
-          def typecast(value)
+          def coerce(value)
             ::JSON.parse(value)
           end
         end
@@ -68,6 +118,12 @@ attributes that require typecasting and/or validations.
     user.info = '{"email":"john@domain.com"}'
     user.info  # => {"email"=>"john@domain.com"}
 
+## Contributors
+
+* Dan Kubb ([dkubb](https://github.com/dkubb))
+* Chris Corbyn ([d11wtq](https://github.com/d11wtq))
+* Emmanuel Gomez ([emmanuel](https://github.com/emmanuel))
+
 ## Note on Patches/Pull Requests
 
 * Fork the project.

data/TODO

@@ -1,4 +1,2 @@
-* Add Virtus::Typecast::Array
-* Add Virtus::Typecast::Hash
-* Add support for default values
-* Add better inspection of attribute instances
+* Make #to_time #to_date and #to_datetime work on Ruby 1.8.7 instead of typecasting to string and parsing the value
+* Add support for defining attributes on Modules

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
-threshold: 19.0
-total_score: 187
+threshold: 20
+total_score: 268

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 17.2
+threshold: 15.9

data/config/roodi.yml

@@ -1,18 +1,17 @@
 ---
-AbcMetricMethodCheck:            { score: 9.5 }
+AbcMetricMethodCheck:            { score: 8.1 }
 AssignmentInConditionalCheck:    { }
 CaseMissingElseCheck:            { }
-ClassLineCountCheck:             { line_count: 404 }
+ClassLineCountCheck:             { line_count: 309 }
 ClassNameCheck:                  { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
 ClassVariableCheck:              { }
 CyclomaticComplexityBlockCheck:  { complexity: 2 }
-CyclomaticComplexityMethodCheck: { complexity: 3 }
+CyclomaticComplexityMethodCheck: { complexity: 4 }
 EmptyRescueBodyCheck:            { }
 ForLoopCheck:                    { }
-# TODO: decrease line_count to 5 to 10
-MethodLineCountCheck:            { line_count: 19 }
+MethodLineCountCheck:            { line_count: 9 }
 MethodNameCheck:                 { pattern: !ruby/regexp /\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|<<|[+*&|-])\z/ }
-ModuleLineCountCheck:            { line_count: 410 }
+ModuleLineCountCheck:            { line_count: 315 }
 ModuleNameCheck:                 { pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/ }
 # TODO: decrease parameter_count to 2 or less
 ParameterNumberCheck:            { parameter_count: 3 }

data/config/site.reek

@@ -11,7 +11,7 @@ LargeClass:
   max_methods: 11
   exclude: []
   enabled: true
-  max_instance_variables: 8
+  max_instance_variables: 7
 UncommunicativeMethodName:
   accept: []
   exclude: []
@@ -21,12 +21,12 @@ UncommunicativeMethodName:
   - !ruby/regexp /[0-9]$/
   - !ruby/regexp /[A-Z]/
 LongParameterList:
-  max_params: 3  # TODO: decrease max_params to 2
+  max_params: 3
   exclude: []
   enabled: true
   overrides: {}
 FeatureEnvy:
-  exclude: []
+  exclude: [Virtus::Coercion::TimeCoercions#to_string, Virtus::Coercion::TimeCoercions#coerce_with_method]
   enabled: true
 ClassVariable:
   exclude: []

data/examples/custom_coercion_spec.rb

@@ -0,0 +1,50 @@
+require './spec/spec_helper'
+
+class MD5 < Virtus::Attribute::Object
+  primitive       String
+  coercion_method :to_md5
+end
+
+module Virtus
+  class Coercion
+    class String < Virtus::Coercion::Object
+      def self.to_md5(value)
+        Digest::MD5.hexdigest(value)
+      end
+    end
+  end
+end
+
+class User
+  include Virtus
+
+  attribute :name,     String
+  attribute :password, MD5
+end
+
+describe User do
+  it { should respond_to(:name)      }
+  it { should respond_to(:name=)     }
+  it { should respond_to(:password)  }
+  it { should respond_to(:password=) }
+
+  describe '#name=' do
+    let(:value) { 'Piotr' }
+
+    before do
+      subject.name = value
+    end
+
+    its(:name) { should == value }
+  end
+
+  describe '#password=' do
+    let(:value) { 'foobar' }
+
+    before do
+      subject.password = value
+    end
+
+    its(:password) { should == Virtus::Coercion::String.to_md5(value) }
+  end
+end

data/examples/default_values_spec.rb

@@ -0,0 +1,21 @@
+require './spec/spec_helper'
+
+class Page
+  include Virtus
+
+  attribute :title,      String
+  attribute :slug,       String,  :default => lambda { |post, attribute| post.title.downcase.gsub(' ', '-') }
+  attribute :view_count, Integer, :default => 0
+end
+
+describe Page do
+  describe '#slug' do
+    before { subject.title = 'Virtus Is Awesome' }
+
+    its(:slug) { should eql('virtus-is-awesome') }
+  end
+
+  describe '#views_count' do
+    its(:view_count) { should eql(0) }
+  end
+end

data/lib/virtus.rb

@@ -13,28 +13,43 @@ module Virtus
   #
   # @param [Class] descendant
   #
-  # @return [Class]
+  # @return [undefined]
   #
   # @api private
   def self.included(descendant)
-    descendant.extend(DescendantsTracker)
+    super
     descendant.extend(ClassMethods)
     descendant.send(:include, InstanceMethods)
   end
 
+  private_class_method :included
+
 end # module Virtus
 
 require 'virtus/support/descendants_tracker'
+require 'virtus/support/type_lookup'
+require 'virtus/support/options'
 
 require 'virtus/class_methods'
 require 'virtus/instance_methods'
 
 require 'virtus/attribute_set'
 
-require 'virtus/typecast/boolean'
-require 'virtus/typecast/numeric'
-require 'virtus/typecast/string'
-require 'virtus/typecast/time'
+require 'virtus/coercion'
+require 'virtus/coercion/object'
+require 'virtus/coercion/numeric'
+require 'virtus/coercion/integer'
+require 'virtus/coercion/float'
+require 'virtus/coercion/decimal'
+require 'virtus/coercion/false_class'
+require 'virtus/coercion/true_class'
+require 'virtus/coercion/hash'
+require 'virtus/coercion/time_coercions'
+require 'virtus/coercion/date'
+require 'virtus/coercion/date_time'
+require 'virtus/coercion/time'
+require 'virtus/coercion/string'
+require 'virtus/coercion/symbol'
 
 require 'virtus/attribute'
 require 'virtus/attribute/object'

data/lib/virtus/attribute.rb

@@ -5,185 +5,8 @@ module Virtus
   # @abstract
   class Attribute
     extend DescendantsTracker
-
-    # Returns a Virtus::Attribute::Object descendant based on a name or class
-    #
-    # @example
-    #   Attribute.determine_type('String')  # => Virtus::Attribute::String
-    #
-    # @param [Class, #to_s] class_or_name
-    #   name of a class or a class itself
-    #
-    # @return [Class]
-    #   one of the Virtus::Attribute::Object descendants
-    #
-    # @return [nil]
-    #   nil if the type cannot be determined by the class_or_name
-    #
-    # @api public
-    def self.determine_type(class_or_name)
-      # first match on the Attribute singleton class first, then match
-      # any class, finally fallback to matching on the string
-      case class_or_name
-      when Attribute::Object.singleton_class then determine_type_from_attribute(class_or_name)
-      when Class                             then determine_type_from_primitive(class_or_name)
-      else
-        determine_type_from_string(class_or_name.to_s)
-      end
-    end
-
-    # Return the Attribute class given an Attribute descendant
-    #
-    # @param [Class<Attribute>] attribute
-    #
-    # @return [Class<Attribute>]
-    #
-    # @api private
-    def self.determine_type_from_attribute(attribute)
-      attribute
-    end
-
-    private_class_method :determine_type_from_attribute
-
-    # Return the Attribute class given a primitive
-    #
-    # @param [Class] primitive
-    #
-    # @return [Class<Attribute>]
-    #
-    # @return [nil]
-    #   nil if the type cannot be determined by the primitive
-    #
-    # @api private
-    def self.determine_type_from_primitive(primitive)
-      descendants.detect { |descendant| primitive <= descendant.primitive }
-    end
-
-    private_class_method :determine_type_from_primitive
-
-    # Return the Attribute class given a string
-    #
-    # @param [String] string
-    #
-    # @return [Class<Attribute>]
-    #
-    # @return [nil]
-    #   nil if the type cannot be determined by the string
-    #
-    # @api private
-    def self.determine_type_from_string(string)
-      const_get(string) if const_defined?(string)
-    end
-
-    private_class_method :determine_type_from_string
-
-    # Returns default options hash for a given attribute class
-    #
-    # @example
-    #   Virtus::Attribute::String.options
-    #   # => {:primitive => String, :complex => false}
-    #
-    # @return [Hash]
-    #   a hash of default option values
-    #
-    # @api public
-    def self.options
-      options = {}
-      accepted_options.each do |option_name|
-        option_value         = send(option_name)
-        options[option_name] = option_value unless option_value.nil?
-      end
-      options
-    end
-
-    # Returns an array of valid options
-    #
-    # @example
-    #   Virtus::Attribute::String.accepted_options
-    #   # => [:primitive, :complex, :accessor, :reader, :writer]
-    #
-    # @return [Array]
-    #   the array of valid option names
-    #
-    # @api public
-    def self.accepted_options
-      @accepted_options ||= []
-    end
-
-    # Defines which options are valid for a given attribute class
-    #
-    # @example
-    #   class MyAttribute < Virtus::Attribute::Object
-    #     accept_options :foo, :bar
-    #   end
-    #
-    # @return [Array]
-    #   All accepted options
-    #
-    # @api public
-    def self.accept_options(*new_options)
-      add_accepted_options(new_options)
-      new_options.each { |option| add_option_method(option) }
-      descendants.each { |descendant| descendant.add_accepted_options(new_options) }
-      self
-    end
-
-    # Adds a reader/writer method for the give option name
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def self.add_option_method(option)
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{option}(value = Undefined)           # def self.primitive(value = Undefined)
-          return @#{option} if value.equal?(Undefined)  #   return @primitive if value.equal?(Undefined)
-          @#{option} = value                            #   @primitive = value
-        end                                             # end
-      RUBY
-    end
-
-    private_class_method :add_option_method
-
-    # Sets default options
-    #
-    # @param [#to_hash] new_options
-    #   options to be set
-    #
-    # @return [self]
-    #
-    # @api private
-    def self.set_options(new_options)
-      new_options.to_hash.each do |option_name, option_value|
-        send(option_name, option_value)
-      end
-      self
-    end
-
-    # Adds new options that an attribute class can accept
-    #
-    # @param [#to_ary] new_options
-    #   new options to be added
-    #
-    # @return [self]
-    #
-    # @api private
-    def self.add_accepted_options(new_options)
-      accepted_options.concat(new_options.to_ary)
-      self
-    end
-
-    # Adds descendant to descendants array and inherits default options
-    #
-    # @param [Class] descendant
-    #
-    # @return [self]
-    #
-    # @api private
-    def self.inherited(descendant)
-      super
-      descendant.add_accepted_options(accepted_options).set_options(options)
-      self
-    end
+    extend TypeLookup
+    extend Options
 
     # Returns if the given value's class is an attribute's primitive
     #
@@ -235,9 +58,24 @@ module Virtus
     # @api private
     attr_reader :writer_visibility
 
+    # Returns method name that should be used for coerceing
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    attr_reader :coercion_method
+
+    # Returns default value
+    #
+    # @return [Object]
+    #
+    # @api private
+    attr_reader :default
+
     DEFAULT_ACCESSOR = :public
 
-    OPTIONS = [ :primitive, :complex, :accessor, :reader, :writer ].freeze
+    OPTIONS = [ :primitive, :accessor, :reader,
+                :writer, :coercion_method, :default ].freeze
 
     accept_options *OPTIONS
 
@@ -257,140 +95,146 @@ module Virtus
       @options = self.class.options.merge(options.to_hash).freeze
 
       @instance_variable_name = "@#{@name}".freeze
-      @complex                = @options.fetch(:complex, false)
+      @coercion_method        = @options.fetch(:coercion_method)
 
+      set_default
       set_visibility
     end
 
-    # Returns if an attribute is a complex one
+    # Returns a concise string representation of the attribute instance
     #
     # @example
-    #   Virtus::Attribute::String.complex?  # => false
-    #   Virtus::Attribute::Array.complex?   # => true
+    #   attribute = Virtus::Attribute::String.new(:name)
+    #   attribute.inspect # => #<Virtus::Attribute::String @name=:name>
     #
-    # @return [Boolean]
+    # @return [String]
     #
     # @api public
-    def complex?
-      @complex
-    end
-
-    # Converts the given value to the primitive type
-    #
-    # @param [Object] value
-    #   the value
-    #
-    # @return [Object]
-    #   nil, original value or value converted to the primitive type
-    #
-    # @api private
-    def typecast(value)
-      if value.nil? || self.class.primitive?(value)
-        value
-      else
-        typecast_to_primitive(value)
-      end
+    def inspect
+      "#<#{self.class.name} @name=#{name.inspect}>"
     end
 
-    # Converts the given value to the primitive type
+    # Returns value of an attribute for the given instance
     #
-    # @return [Object]
+    # Sets the default value if an ivar is not set and default
+    # value is configured
     #
-    # @api private
-    def typecast_to_primitive(value)
-      value
-    end
-
-    # Returns value of an attribute for the given instance
+    # @example
+    #   attribute.get(instance)  # => value
     #
     # @return [Object]
     #   value of an attribute
     #
-    # @api private
+    # @api public
     def get(instance)
-      get!(instance)
+      if instance.instance_variable_defined?(instance_variable_name)
+        get!(instance)
+      else
+        set_default_value(instance)
+      end
     end
 
     # Returns the instance variable of the attribute
     #
+    # @example
+    #   attribute.get!(instance)  # => value
+    #
     # @return [Object]
     #   value of an attribute
     #
-    # @api private
+    # @api public
     def get!(instance)
       instance.instance_variable_get(instance_variable_name)
     end
 
     # Sets the value on the instance
     #
-    # @return [Object]
-    #   value of an attribute
+    # @example
+    #   attribute.set(instance, value)  # => value
     #
-    # @api private
+    # @return [self]
+    #
+    # @api public
     def set(instance, value)
-      set!(instance, typecast(value)) unless value.nil?
+      set!(instance, coerce(value))
     end
 
     # Sets instance variable of the attribute
     #
-    # @return [Object]
-    #   value of an attribute
+    # @example
+    #   attribute.set!(instance, value)  # => value
     #
-    # @api private
+    # @return [self]
+    #
+    # @api public
     def set!(instance, value)
       instance.instance_variable_set(instance_variable_name, value)
     end
 
+    # Converts the given value to the primitive type
+    #
+    # @example
+    #   attribute.coerce(value)  # => primitive_value
+    #
+    # @param [Object] value
+    #   the value
+    #
+    # @return [Object]
+    #   nil, original value or value converted to the primitive type
+    #
+    # @api public
+    def coerce(value)
+      Coercion[value.class].send(coercion_method, value)
+    end
+
     # Creates an attribute reader method
     #
+    # @param [Module] mod
+    #
     # @return [self]
     #
     # @api private
-    def add_reader_method(model)
-      instance_variable_name = self.instance_variable_name
-      method_name            = name
-
-      model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        module AttributeMethods                                                      # module AttributeMethods
-          def #{method_name}                                                         #   def name
-            return #{instance_variable_name} if defined?(#{instance_variable_name})  #     return @name if defined?(@name)
-            attribute = self.class.attributes[#{method_name.inspect}]                #     attribute = self.class.attributes[:name]
-            #{instance_variable_name} = attribute ? attribute.get(self) : nil        #     @name = attribute ? attribute.get(self) : nil
-          end                                                                        #   end
-        end                                                                          # end
-        include AttributeMethods                                                     # include AttributeMethods
-      RUBY
-
-      model.send(reader_visibility, method_name)
+    def define_reader_method(mod)
+      reader_method_name = name
+      attribute          = self
+
+      mod.send(:define_method,    reader_method_name) { attribute.get(self) }
+      mod.send(reader_visibility, reader_method_name)
 
       self
     end
 
     # Creates an attribute writer method
     #
+    # @param [Module] mod
+    #
     # @return [self]
     #
     # @api private
-    def add_writer_method(model)
-      name        = self.name
-      method_name = "#{name}="
-
-      model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        module AttributeMethods                                      # module AttributeMethods
-          def #{method_name}(value)                                  #   def name=(value)
-            self.class.attributes[#{name.inspect}].set(self, value)  #     self.class.attributes[:name].set(self, value)
-          end                                                        #   end
-        end                                                          # end
-        include AttributeMethods                                     # include AttributeMethods
-      RUBY
+    def define_writer_method(mod)
+      writer_method_name = "#{name}="
+      attribute          = self
 
-      model.send(writer_visibility, method_name)
+      mod.send(:define_method,    writer_method_name) { |value| attribute.set(self, value) }
+      mod.send(writer_visibility, writer_method_name)
 
       self
     end
 
   private
 
+    # Sets a default value
+    #
+    # @param [Object]
+    #
+    # @return [Object]
+    #   default value that was set
+    #
+    # @api private
+    def set_default_value(instance)
+      set!(instance, default.kind_of?(Proc) ? default.call(instance, self) : default)
+    end
+
     # Sets visibility of reader/write methods based on the options hash
     #
     # @return [undefined]
@@ -398,8 +242,24 @@ module Virtus
     # @api private
     def set_visibility
       default_accessor   = @options.fetch(:accessor, self.class::DEFAULT_ACCESSOR)
-      @reader_visibility = @options.fetch(:reader, default_accessor)
-      @writer_visibility = @options.fetch(:writer, default_accessor)
+      @reader_visibility = @options.fetch(:reader,   default_accessor)
+      @writer_visibility = @options.fetch(:writer,   default_accessor)
+    end
+
+    # Sets default value option
+    #
+    # @return [Object]
+    #
+    # @api private
+    def set_default
+      default = @options[:default]
+
+      @default = case default
+                 when Proc, ::NilClass, ::TrueClass, ::FalseClass, ::Numeric, ::Symbol
+                   default
+                 else
+                   default.dup
+                 end
     end
 
   end # class Attribute