virtus 1.0.0.beta7 → 1.0.0.beta8

data/README.md

@@ -476,6 +476,9 @@ class User
 end
 ```
 
+Please check out [Coercible README](https://github.com/solnic/coercible/blob/master/README.md)
+for more information.
+
 ## Strict Coercion Mode
 
 By default Virtus returns the input value even when it couldn't coerce it to the expected type.
@@ -519,8 +522,34 @@ class User
 end
 ```
 
-Please check out [Coercible README](https://github.com/solnic/coercible/blob/master/README.md)
-for more information.
+## Attribute Finalization and Circular Dependencies
+
+If a type references another type which happens to not be available yet you need
+to use lazy-finalization of attributes and finalize virtus manually after all 
+types have been already loaded:
+
+``` ruby
+# in blog.rb
+class Blog
+  include Virtus.model(:finalize => false)
+
+  attribute :posts, Array['Post']
+end
+
+# in post.rb
+class Post
+  include Virtus.model(:finalize => false)
+
+  attribute :blog, 'Blog'
+end
+
+# after loading both files just do:
+Virtus.finalize
+
+# constants will be resolved:
+Blog.attribute_set[:posts].member_type.primitive # => Post
+Post.attribute_set[:blog].type.primitive # => Blog
+```
 
 Credits
 -------

data/lib/virtus.rb

@@ -150,6 +150,13 @@ module Virtus
     @configuration ||= Configuration.new
   end
 
+  # @api public
+  def self.finalize
+    ExtensionBuilder.pending.each do |klass|
+      klass.attribute_set.finalize
+    end
+  end
+
   # @api private
   def self.warn(msg)
     Kernel.warn(msg)

data/lib/virtus/attribute.rb

@@ -5,11 +5,12 @@ module Virtus
 
     include ::Equalizer.new(:type, :options)
 
-    accept_options :primitive, :accessor, :default, :lazy, :strict, :required
+    accept_options :primitive, :accessor, :default, :lazy, :strict, :required, :finalize
 
     strict false
     required true
     accessor :public
+    finalize true
 
     # @see Virtus.coerce
     #
@@ -55,12 +56,12 @@ module Virtus
     def self.new(*args)
       attribute = super
       yield(attribute)
-      attribute.finalize
+      attribute
     end
 
     # @api private
-    def self.build_type(options)
-      Axiom::Types.infer(options[:primitive])
+    def self.build_type(definition)
+      Axiom::Types.infer(definition.primitive)
     end
 
     # @api private
@@ -126,6 +127,11 @@ module Virtus
       options[:required]
     end
 
+    # @api public
+    def finalized?
+      frozen?
+    end
+
     # @api private
     def define_accessor_methods(attribute_set)
       attribute_set.define_reader_method(self, name,       options[:reader])
@@ -135,6 +141,7 @@ module Virtus
     # @api private
     def finalize
       freeze
+      self
     end
 
   end # class Attribute

data/lib/virtus/attribute/builder.rb

@@ -1,4 +1,79 @@
 module Virtus
+
+  # @private
+  class PendingAttribute
+    attr_reader :name
+
+    # @api private
+    def initialize(type, options)
+      @type    = type
+      @options = options
+      @name    = options[:name]
+    end
+
+    # @api private
+    def finalize
+      Attribute::Builder.call(determine_type, @options).finalize
+    end
+
+    # @api private
+    def finalized?
+      false
+    end
+
+    # @api private
+    def determine_type
+      if @type.include?('::')
+        # TODO: wrap it up in Virtus.constantize and use feature-detection to
+        #       pick up either Inflecto or ActiveSupport, whateve is available
+        if defined?(Inflecto)
+          Inflecto.constantize(@type)
+        else
+          raise NotImplementedError, 'Virtus needs inflecto gem to constantize namespaced constant names'
+        end
+      else
+        Object.const_get(@type)
+      end
+    end
+
+  end # PendingAttribute
+
+  class TypeDefinition
+    attr_reader :type, :primitive
+
+    # @api private
+    def initialize(type)
+      @type = type
+      initialize_primitive
+    end
+
+    # @api private
+    def pending?
+      @pending
+    end
+
+    private
+
+    # @api private
+    def initialize_primitive
+      @primitive =
+        if type.instance_of?(String) || type.instance_of?(Symbol)
+          if !type.to_s.include?('::') && Object.const_defined?(type)
+            Object.const_get(type)
+          elsif not Attribute::Builder.determine_type(type)
+            @pending = true
+            type
+          else
+            type
+          end
+        elsif not type.is_a?(Class)
+          type.class
+        else
+          type
+        end
+    end
+  end
+
   class Attribute
 
     # TODO: this is a huge class and it might be a good idea to split it into
@@ -10,8 +85,14 @@ module Virtus
       attr_reader :attribute
 
       # @api private
-      def self.call(*args)
-        new(*args).attribute
+      def self.call(type, options = {})
+        type_definition = TypeDefinition.new(type)
+
+        if type_definition.pending?
+          PendingAttribute.new(type, options)
+        else
+          new(type_definition, options).attribute
+        end
       end
 
       # @api private
@@ -33,10 +114,11 @@ module Virtus
       end
 
       # @api private
-      def initialize(type, options)
-        initialize_primitive(type)
+      def initialize(type_definition, options)
+        @type_definition = type_definition
+
         initialize_class
-        initialize_type(:type => type, :primitive => @primitive)
+        initialize_type
         initialize_options(options)
         initialize_default_value
         initialize_coercer
@@ -45,50 +127,14 @@ module Virtus
 
       private
 
-      # @api private
-      def initialize_attribute
-        @attribute = @klass.new(@type, @options) do |attribute|
-          attribute.extend(Accessor)    if @options[:name]
-          attribute.extend(Coercible)   if @options[:coerce]
-          attribute.extend(Strict)      if @options[:strict]
-          attribute.extend(LazyDefault) if @options[:lazy]
-        end
-      end
-
-      # @api private
-      def initialize_default_value
-        @options.update(:default_value => DefaultValue.build(@options[:default]))
-      end
-
-      # @api private
-      def initialize_coercer
-        @options.update(:coercer => @options.fetch(:coercer) { @klass.build_coercer(@type, @options) })
-      end
-
-      # @api private
-      def initialize_primitive(type)
-        @primitive =
-          if type.instance_of?(String) || type.instance_of?(Symbol)
-            begin
-              Object.const_get(type)
-            rescue
-              type
-            end
-          elsif not type.is_a?(Class)
-            type.class
-          else
-            type
-          end
-      end
-
       # @api private
       def initialize_class
-        @klass = self.class.determine_type(@primitive, Attribute)
+        @klass = self.class.determine_type(@type_definition.primitive, Attribute)
       end
 
       # @api private
-      def initialize_type(options)
-        @type = @klass.build_type(options)
+      def initialize_type
+        @type = @klass.build_type(@type_definition)
       end
 
       # @api private
@@ -106,6 +152,27 @@ module Virtus
         @options.update(:reader => reader_visibility, :writer => writer_visibility)
       end
 
+      # @api private
+      def initialize_default_value
+        @options.update(:default_value => DefaultValue.build(@options[:default]))
+      end
+
+      # @api private
+      def initialize_coercer
+        @options.update(:coercer => @options.fetch(:coercer) { @klass.build_coercer(@type, @options) })
+      end
+
+      # @api private
+      def initialize_attribute
+        @attribute = @klass.new(@type, @options) do |attribute|
+          attribute.extend(Accessor)    if @options[:name]
+          attribute.extend(Coercible)   if @options[:coerce]
+          attribute.extend(Strict)      if @options[:strict]
+          attribute.extend(LazyDefault) if @options[:lazy]
+        end
+        @attribute.finalize if @options[:finalize]
+      end
+
     end # class Builder
 
   end # class Attribute

data/lib/virtus/attribute/collection.rb

@@ -9,15 +9,17 @@ module Virtus
     class Collection < Attribute
       default Proc.new { |_, attribute| attribute.type.primitive.new }
 
+      attr_reader :member_type
+
       # FIXME: temporary hack, remove when Axiom::Type works with EV as member_type
       Type = Struct.new(:primitive, :member_type) do
         def self.infer(type, primitive)
-          return type if type.is_a?(Class) && type < Axiom::Types::Type
+          return type if axiom_type?(type)
 
           klass  = Axiom::Types.infer(type)
           member = infer_member_type(type) || Object
 
-          if EmbeddedValue.handles?(member)
+          if EmbeddedValue.handles?(member) || pending?(member)
             Type.new(primitive, member)
           else
             klass.new {
@@ -27,6 +29,14 @@ module Virtus
           end
         end
 
+        def self.pending?(primitive)
+          primitive.is_a?(String) || primitive.is_a?(Symbol)
+        end
+
+        def self.axiom_type?(type)
+          type.is_a?(Class) && type < Axiom::Types::Type
+        end
+
         def self.infer_member_type(type)
           return unless type.respond_to?(:count)
 
@@ -43,8 +53,8 @@ module Virtus
       end
 
       # @api private
-      def self.build_type(options)
-        Type.infer(options.fetch(:type), options.fetch(:primitive))
+      def self.build_type(definition)
+        Type.infer(definition.type, definition.primitive)
       end
 
       # @api private
@@ -61,10 +71,19 @@ module Virtus
         end
       end
 
-      def member_type
-        @options[:member_type]
+      # @api private
+      def finalize
+        return self if finalized?
+        @member_type = @options[:member_type].finalize
+        super
+      end
+
+      # @api private
+      def finalized?
+        super && member_type.finalized?
       end
 
     end # class Collection
+
   end # class Attribute
 end # module Virtus

data/lib/virtus/attribute/embedded_value.rb

@@ -66,8 +66,9 @@ module Virtus
       end
 
       # @api private
-      def self.build_type(options)
-        Axiom::Types::Object.new { primitive options[:type] }
+      def self.build_type(definition)
+        klass = definition.primitive.is_a?(Class) ? definition.primitive : definition.type
+        Axiom::Types::Object.new { primitive klass }
       end
 
       # @api private

data/lib/virtus/attribute/hash.rb

@@ -16,10 +16,13 @@ module Virtus
       primitive ::Hash
       default   primitive.new
 
+      attr_reader :key_type
+      attr_reader :value_type
+
       # FIXME: remove this once axiom-types supports it
       Type = Struct.new(:key_type, :value_type) do
         def self.infer(type)
-          if type.is_a?(Class) && type < Axiom::Types::Type
+          if axiom_type?(type)
             new(type.key_type, type.value_type)
           else
             type_options = infer_key_and_value_types(type)
@@ -30,7 +33,17 @@ module Virtus
           end
         end
 
+        def self.pending?(primitive)
+          primitive.is_a?(String) || primitive.is_a?(Symbol)
+        end
+
+        def self.axiom_type?(type)
+          type.is_a?(Class) && type < Axiom::Types::Type
+        end
+
         def self.determine_type(type)
+          return type if pending?(type)
+
           if EmbeddedValue.handles?(type)
             type
           else
@@ -58,8 +71,8 @@ module Virtus
       end
 
       # @api private
-      def self.build_type(options)
-        Type.infer(options[:type])
+      def self.build_type(definition)
+        Type.infer(definition.type)
       end
 
       # @api private
@@ -85,13 +98,16 @@ module Virtus
       end
 
       # @api private
-      def key_type
-        @options[:key_type]
+      def finalize
+        return self if finalized?
+        @key_type   = options[:key_type].finalize
+        @value_type = options[:value_type].finalize
+        super
       end
 
       # @api private
-      def value_type
-        @options[:value_type]
+      def finalized?
+        super && key_type.finalized? && value_type.finalized?
       end
 
     end # class Hash

data/lib/virtus/attribute_set.rb

@@ -74,7 +74,8 @@ module Virtus
     # @api public
     def <<(attribute)
       self[attribute.name] = attribute
-      attribute.define_accessor_methods(self)
+      attribute.define_accessor_methods(self) if attribute.finalized?
+      self
     end
 
     # Get an attribute by name
@@ -208,6 +209,13 @@ module Virtus
       )
     end
 
+    # @api private
+    def finalize
+      each do |attribute|
+        self << attribute.finalize unless attribute.finalized?
+      end
+    end
+
     private
 
     # @api private

data/lib/virtus/configuration.rb

@@ -3,6 +3,9 @@ module Virtus
   # A Configuration instance
   class Configuration
 
+    # Access the finalize setting for this instance
+    attr_accessor :finalize
+
     # Access the coerce setting for this instance
     attr_accessor :coerce
 
@@ -35,6 +38,7 @@ module Virtus
     #
     # @api private
     def initialize
+      @finalize        = true
       @coerce          = true
       @strict          = false
       @constructor     = true

data/lib/virtus/module_builder.rb

@@ -44,6 +44,11 @@ module Virtus
       builder.module
     end
 
+    # @api private
+    def self.pending
+      @pending ||= []
+    end
+
     # Initializes a new ModuleBuilder
     #
     # @param [Configuration] configuration
@@ -68,11 +73,13 @@ module Virtus
       attribute_proc  = attribute_method(configuration)
       constructor     = configuration.constructor
       mass_assignment = configuration.mass_assignment
+      finalize        = configuration.finalize
       extensions      = core_extensions
       inclusions      = core_inclusions
 
       self.module.define_singleton_method :included do |object|
         super(object)
+        ExtensionBuilder.pending << object unless finalize
         extensions.each { |mod| object.extend(mod) }
         inclusions.each { |mod| object.send(:include, mod) }
         object.send(:include, Model::Constructor)    if constructor
@@ -114,6 +121,7 @@ module Virtus
     # @api private
     def module_options
       { :coerce             => configuration.coerce,
+        :finalize           => configuration.finalize,
         :strict             => configuration.strict,
         :configured_coercer => configuration.coercer }
     end

data/lib/virtus/version.rb

@@ -1,3 +1,3 @@
 module Virtus
-  VERSION = '1.0.0.beta7'
+  VERSION = '1.0.0.beta8'
 end

data/spec/spec_helper.rb

@@ -19,6 +19,7 @@ end
 require 'rspec'
 require 'bogus/rspec'
 require 'virtus'
+require 'inflecto' # for resolving namespaced constant names
 
 module Virtus
   def self.warn(*)

data/spec/unit/virtus/attribute/collection/coerce_spec.rb

@@ -17,6 +17,7 @@ describe Virtus::Attribute::Collection, '#coerce' do
 
       it 'uses coercer to coerce members' do
         stub(coercer).call(input) { input }
+        stub(member_type).finalize { member_type }
         stub(member_type).coerce('1') { 1 }
         stub(member_type).coerce('2') { 2 }
 

data/spec/unit/virtus/attribute/hash/coerce_spec.rb

@@ -41,9 +41,11 @@ describe Virtus::Attribute::Hash, '#coerce' do
       it 'uses coercer to coerce key and value' do
         stub(coercer).call(input) { input }
 
+        stub(key_type).finalize { key_type }
         stub(key_type).coerce(1) { '1' }
         stub(key_type).coerce(2) { '2' }
 
+        stub(value_type).finalize { value_type }
         stub(value_type).coerce('1') { 1 }
         stub(value_type).coerce('2') { 2 }
 

data/spec/unit/virtus/class_methods/finalize_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Virtus, '.finalize' do
+  before do
+    module Examples
+      class Person
+        include Virtus.model(:finalize => false)
+
+        attribute :articles, Array['Examples::Article']
+        attribute :address,  'Examples::Address'
+      end
+
+      class Article
+        include Virtus.model(:finalize => false)
+
+        attribute :posts, Hash['Examples::Person' => 'Examples::Post']
+        attribute :person, 'Examples::Person'
+      end
+
+      class Post
+        include Virtus.model(:finalize => false)
+
+        attribute :title, String
+      end
+
+      class Address
+        include Virtus.model(:finalize => false)
+
+        attribute :street, String
+      end
+    end
+
+    Virtus.finalize
+  end
+
+  it 'it finalizes member type for a collection attribute' do
+    expect(Examples::Person.attribute_set[:address].primitive).to be(Examples::Address)
+  end
+
+  it 'it finalizes key type for a hash attribute' do
+    expect(Examples::Article.attribute_set[:posts].key_type.primitive).to be(Examples::Person)
+  end
+
+  it 'it finalizes value type for a hash attribute' do
+    expect(Examples::Article.attribute_set[:posts].value_type.primitive).to be(Examples::Post)
+  end
+
+  it 'it finalizes type for an EV attribute' do
+    expect(Examples::Article.attribute_set[:person].type.primitive).to be(Examples::Person)
+  end
+
+  it 'automatically resolves constant when it is already available' do
+    expect(Examples::Article.attribute_set[:person].type.primitive).to be(Examples::Person)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: virtus
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta7
+  version: 1.0.0.beta8
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-26 00:00:00.000000000 Z
+date: 2013-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: descendants_tracker
@@ -189,6 +189,7 @@ files:
 - spec/unit/virtus/attribute_spec.rb
 - spec/unit/virtus/attributes_reader_spec.rb
 - spec/unit/virtus/attributes_writer_spec.rb
+- spec/unit/virtus/class_methods/finalize_spec.rb
 - spec/unit/virtus/class_methods/new_spec.rb
 - spec/unit/virtus/config_spec.rb
 - spec/unit/virtus/element_reader_spec.rb