attrio 0.1.1 → 0.2.0

data/README.md

@@ -6,7 +6,7 @@
 
 # Attrio
 
-Attributes for plain Ruby objects. The goal is to provide an ability to define attributes for your models without reinventing the wheel all over again. Attrio doesn't have any third-party dependencies like Virtus or ActiveAttr and does not redefine any methods inside your class, unless you want it to.
+Attributes for plain Ruby objects. The goal is to provide an ability to define attributes for your models without reinventing the wheel all over again. Attrio doesn't have any third-party dependencies like [Virtus](https://github.com/solnic/virtus) or [ActiveAttr](https://github.com/cgriego/active_attr) and does not redefine any methods inside your class, unless you want it to.
 
 ## Installation
 
@@ -38,7 +38,7 @@ class User
 end
 ```
 
-By default Attrio creates `#attributes` accessor which contains `Hash` of with attributes names as keys and instances of `Attrio::Attribute` as values. Each instance of `Attrio::Attribute` contains following information:
+By default Attrio defines `#attributes` accessor which contains `Hash` with attributes names as keys and instances of `Attrio::Attribute` as values. Each instance of `Attrio::Attribute` contains following information:
  * type
  * writer method name
  * writer method visibility
@@ -57,7 +57,7 @@ user.attributes
 # }
 ```
 
-Accessor name can be easily overriden by passing `:as` option to `define_attributes` block.
+Accessor name can be easily overridden by passing `:as` option to `define_attributes` block.
 
 ```ruby
 class User
@@ -76,6 +76,120 @@ user = User.new
 user.api_attributes # => {...}
 ```
 
+### Default values
+
+Attrio supports all the ways to setup default values that Virtus has.
+
+```ruby
+class Page
+  include Attrio
+
+  define_attributes do
+    attr :title, String
+
+    # default from a singleton value (integer in this case)
+    attr :views, Integer, :default => 0
+
+    # default from a singleton value (boolean in this case)
+    attr :published, Boolean, :default => false
+
+    # default from a callable object (proc in this case)
+    attr :slug, String, :default => lambda { |page, attribute| page.title.present? ? page.title.downcase.gsub(' ', '-') : nil }
+
+    # default from a method name as symbol
+    attr :editor_title, String,  :default => :default_editor_title
+  end
+  
+  def initialize(attributes = {})
+    self.attributes = attributes
+  end
+
+  def attributes=(attributes = {})
+    attributes.each do |attr,value|
+      self.send("#{attr}=", value) if self.respond_to?("#{attr}=")
+    end
+  end
+
+  def default_editor_title
+    if self.published?
+      title
+    else
+      title.present? ? "UNPUBLISHED: #{title}" : "UNPUBLISHED"
+    end    
+  end
+end
+```
+
+### Embed Value
+You can embed values in Attrio just like you do it in Virtus.
+
+```ruby
+module MassAssignment
+  def initialize(attributes = {})
+    self.attributes = attributes
+  end
+
+  def attributes=(attributes = {})
+    attributes.each do |attr,value|
+      self.send("#{attr}=", value) if self.respond_to?("#{attr}=")
+    end
+  end
+end
+
+class City  
+  include Attrio
+  include MassAssignment
+
+  define_attributes do
+    attr :name, String
+  end
+end
+
+class Address
+  include Attrio
+  include MassAssignment
+
+  define_attributes do
+    attr :street,  String
+    attr :zipcode, String
+    attr :city,    City
+  end
+end
+
+class User
+  include Attrio
+  include MassAssignment
+
+  define_attributes do
+    attr :name,    String
+    attr :address, Address
+  end
+end
+
+user = User.new( :address => { :street => 'Sklizkova 6A', :zipcode => '170000', :city => { :name => 'Tver' } } )
+user.address.street
+# => 'Sklizkova 6A'
+user.address.zipcode
+# => '170000'
+user.address.city.name
+# => 'Tver'
+```
+
+### Methods visibility
+
+Don't want your accessors to be public? Visibility can be overridden easily. 
+
+```ruby
+class User
+  include Attrio
+	
+  define_attributes do
+  	attr :name, String, :writer => :protected
+    attr :secret_rating, Integer, :reader => :private
+  end
+end
+```
+
 ### Types
 
 Any Ruby class can be passed as type to Attrio. If this class responds to `typecast` and `typecasted?` methods then they will be called, else `new` will be called.
@@ -185,7 +299,7 @@ class Klass
   include Attrio
 	
   define_attributes :inspect => false do
-  	attr :attribute, Atring
+  	attr :attribute, String
   end
 end
 ```

data/lib/attrio.rb

@@ -11,27 +11,37 @@ require 'attrio/core_ext/string'
 require 'attrio/core_ext/time'
 
 module Attrio
-  autoload :AttributesParser, 'attrio/attributes_parser'
-  autoload :Attribute, 'attrio/attribute'
+  autoload :AttributesParser, 'attrio/attributes_parser'  
   autoload :Initialize, 'attrio/initialize'
   autoload :Inspect, 'attrio/inspect'
   autoload :Reset, 'attrio/reset'
 
   def self.included(base)    
-    base.send(:include, Attrio::Initialize)
-    base.send(:include, Attrio::Inspect)
-    base.send(:include, Attrio::Reset)
+    base.send :include, Attrio::Initialize
+    base.send :include, Attrio::Inspect
+    base.send :include, Attrio::Reset
 
-    base.send(:extend, Attrio::ClassMethods)    
+    base.send :extend, Attrio::ClassMethods
   end
 
   module ClassMethods
     def define_attributes(options = {}, &block)
       options[:as] ||= :attributes
       
-      cattr_accessor options[:as].to_sym
-      class_eval(<<-EOS)
-        @@#{options[:as].to_s} ||= {}
+      # cattr_accessor options[:as].to_sym
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        @@#{options[:as]} ||= {}
+
+        def self.#{options[:as]}(attributes = [])
+          attributes = Array.wrap(attributes).flatten
+          return @@#{options[:as]} if attributes.empty?
+
+          @@#{options[:as]}.slice(attributes.map { |attr| attr.to_sym })                    
+        end
+
+        def #{options[:as]}(attributes = [])
+          self.class.#{options[:as]}(attributes)
+        end
       EOS
 
       self.define_attrio_new(options[:as])
@@ -46,6 +56,9 @@ module Attrio
     end    
   end
 
+  autoload :Attribute, 'attrio/attribute'
+  autoload :DefaultValue, 'attrio/default_value'
+
   module Builders
     autoload :ReaderBuilder, 'attrio/builders/reader_builder'
     autoload :WriterBuilder, 'attrio/builders/writer_builder'

data/lib/attrio/attribute.rb

@@ -2,10 +2,10 @@
 
 module Attrio
   class Attribute
-    attr_reader :object, :name, :type, :options
+    attr_reader :klass, :name, :type, :options
 
-    def initialize(object, name, type, options)
-      @object = object; @name = name; @type = type; @options = options.symbolize_keys   
+    def initialize(klass, name, type, options)
+      @klass = klass; @name = name; @type = type; @options = options.symbolize_keys   
     end
 
     def reader_method_name
@@ -29,11 +29,14 @@ module Attrio
     end
 
     def default_value
-      self.options[:default] || self.options[:default_value]
+      if !defined?(@default_value)
+        @default_value = Attrio::DefaultValue.new(self.klass, self.name, self.options[:default])
+      end
+      @default_value      
     end
 
     def define_writer
-      Attrio::Builders::WriterBuilder.define(self.object, self.type,
+      Attrio::Builders::WriterBuilder.define(self.klass, self.type,
         self.options.merge({
           :method_name => self.writer_method_name,
           :method_visibility => self.writer_visibility,
@@ -44,7 +47,7 @@ module Attrio
     end
 
     def define_reader
-      Attrio::Builders::ReaderBuilder.define(self.object, self.type,
+      Attrio::Builders::ReaderBuilder.define(self.klass, self.type,
         self.options.merge({
           :method_name => self.reader_method_name,
           :method_visibility => self.reader_visibility,

data/lib/attrio/builders/accessor_builder.rb

@@ -7,15 +7,15 @@ module Attrio
         raise NotImplementedError
       end
 
-      def self.define(object, type, options)
-        self.define_accessor(object, type, options)
-        self.define_aliases(object, type, options)
+      def self.define(klass, type, options)
+        self.define_accessor(klass, type, options)
+        self.define_aliases(klass, type, options)
       end
 
-      def self.define_aliases(object, type, options)
+      def self.define_aliases(klass, type, options)
         if type.respond_to?("default_#{self.accessor.to_s}_aliases")
           type.send("default_#{self.accessor.to_s}_aliases", options[:method_name]).each do |alias_method_name|
-            object.send(:alias_method, alias_method_name, options[:method_name])
+            klass.send(:alias_method, alias_method_name, options[:method_name])
           end
         end        
       end

data/lib/attrio/builders/reader_builder.rb

@@ -9,13 +9,13 @@ module Attrio
         :reader
       end
 
-      def self.define_accessor(object, type, options)
-        unless object.method_defined?(options[:method_name])
-          object.send :define_method, options[:method_name] do            
+      def self.define_accessor(klass, type, options)
+        unless klass.method_defined?(options[:method_name])
+          klass.send :define_method, options[:method_name] do            
             self.instance_variable_get(options[:instance_variable_name])
           end
         
-          object.send options[:method_visibility], options[:method_name]
+          klass.send options[:method_visibility], options[:method_name]
         end        
       end      
     end

data/lib/attrio/builders/writer_builder.rb

@@ -9,14 +9,21 @@ module Attrio
         :writer
       end
 
-      def self.define_accessor(object, type, options)
-        unless object.method_defined?(options[:method_name])
-          object.send :define_method, options[:method_name] do |value|
-            value = type.respond_to?(:typecast) ? type._typecast(*[value, options]) : type.new(value) if !value.nil?
+      def self.define_accessor(klass, type, options)
+        unless klass.method_defined?(options[:method_name])
+          klass.send :define_method, options[:method_name] do |value|
+            if !value.nil?
+              value = if type.respond_to?(:typecast) && type.respond_to?(:typecasted?)
+                type.typecasted?(value) ? value : type.typecast(*[value, options])
+              else
+                type.new(value)
+              end
+            end
+            
             self.instance_variable_set(options[:instance_variable_name], value)
           end
         
-          object.send options[:method_visibility], options[:method_name]
+          klass.send options[:method_visibility], options[:method_name]
         end        
       end      
     end

data/lib/attrio/core_ext/hash.rb

@@ -28,4 +28,11 @@ class Hash # :nodoc:
   def extractable_options?
     instance_of?(Hash)
   end unless method_defined?(:extractable_options?)
+
+  def slice(*keys)
+    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end unless method_defined?(:slice?)
 end # Hash

data/lib/attrio/default_value.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Attrio
+  module DefaultValue
+    autoload :Base, 'attrio/default_value/base'
+    autoload :Callable, 'attrio/default_value/callable'
+    autoload :Clonable, 'attrio/default_value/clonable'
+    autoload :Symbol, 'attrio/default_value/symbol'
+
+    class << self      
+      def new(object, attribute, value)
+        Attrio::DefaultValue::Base.handle(object, attribute, value) || value
+      end
+    end
+  end
+end

data/lib/attrio/default_value/base.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Attrio
+  module DefaultValue
+    class Base
+      attr_reader :klass, :attribute, :value
+
+      def self.handle(klass, attribute, value)
+        handler = [
+          Attrio::DefaultValue::Callable,
+          Attrio::DefaultValue::Clonable,
+          Attrio::DefaultValue::Symbol
+        ].detect{ |handler| handler.handle?(value) }
+
+        handler.new(klass, attribute, value) if handler.present?
+      end
+
+      def initialize(klass, attribute, value)
+        @klass = klass; @attribute = attribute; @value = value;
+      end
+
+      # Evaluates the value      
+      # @return [Object] evaluated value
+      #      
+      def call(instance)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/attrio/default_value/callable.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'attrio/default_value/base'
+
+module Attrio
+  module DefaultValue
+    class Callable < Base
+      def self.handle?(value)
+        value.respond_to?(:call)
+      end
+
+      # Evaluates the value via value#call
+      #
+      # @param [Object] instance
+      #
+      # @return [Object] evaluated value
+      #
+      def call(instance)
+        self.value.call(instance, self.attribute)
+      end    
+    end
+  end
+end

data/lib/attrio/default_value/clonable.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'attrio/default_value/base'
+
+module Attrio
+  module DefaultValue
+    class Clonable < Base
+      SINGLETON_CLASSES = [::NilClass, ::TrueClass, ::FalseClass, ::Numeric,  ::Symbol ].freeze
+
+      def self.handle?(value)
+        case value
+        when *SINGLETON_CLASSES
+          false
+        else
+          true
+        end
+      end
+
+      # Evaluates the value via value#clone
+      #
+      # @return [Object] evaluated value
+      #        
+      def call(*)
+        @value.clone
+      end 
+    end
+  end
+end

data/lib/attrio/default_value/symbol.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'attrio/default_value/base'
+
+module Attrio
+  module DefaultValue
+    class Symbol < Base
+      def self.handle?(value)
+        value.is_a?(::Symbol)
+      end
+
+      # Evaluates the value via self.object#send(value)
+      # Symbol value is returned if the object doesn't respond to value
+      #
+      # @param [Object] instance
+      #      
+      def call(instance)
+        instance.respond_to?(self.value, true) ? instance.send(self.value) : self.value
+      end     
+    end
+  end
+end