motion_virtus 1.0.0.beta0

data/lib/project/attribute.rb

@@ -0,0 +1,292 @@
+motion_require 'virtus'
+
+module Virtus
+
+  # Abstract class implementing base API for attribute types
+  #
+  # @abstract
+  class Attribute
+    extend DescendantsTracker, TypeLookup, Options
+
+    #include Adamantium::Flat
+    include Equalizer.new(inspect) << :name
+
+    accept_options :primitive, :accessor, :reader,
+      :writer, :coercion_method, :default, :lazy
+
+    accessor :public
+
+    # @see Virtus.coerce
+    #
+    # @deprecated
+    #
+    # @api public
+    def self.coerce(value = Undefined)
+      warn "#{self}.coerce is deprecated and will be removed in a future version. Use Virtus.coerce instead: ##{caller.first}"
+      return Virtus.coerce if value.equal?(Undefined)
+      Virtus.coerce = value
+      self
+    end
+
+    # Returns name of the attribute
+    #
+    # @example
+    #   User.attributes[:age].name  # => :age
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    attr_reader :name
+
+    # Return accessor object
+    #
+    # @return [Accessor]
+    #
+    # @api private
+    attr_reader :accessor
+
+    # Builds an attribute instance
+    #
+    # @param [Symbol] name
+    #   the name of an attribute
+    #
+    # @param [Class] type
+    #   optional type class of an attribute
+    #
+    # @param [#to_hash] options
+    #   optional extra options hash
+    #
+    # @return [Attribute]
+    #
+    # @api private
+    def self.build(name, type = Object, options = {})
+      klass = determine_type(type) or raise(
+        ArgumentError, "#{type.inspect} does not map to an attribute type"
+      )
+
+      attribute_options = klass.merge_options(type, options)
+      accessor          = Accessor.build(name, klass, attribute_options)
+
+      klass.new(name, accessor)
+    end
+
+    # Build coercer wrapper
+    #
+    # @example
+    #
+    #   Virtus::Attribute.coercer # => #<Virtus::Attribute::Coercer ...>
+    #
+    # @return [Coercer]
+    #
+    # @api public
+    def self.coercer(type = nil, options = {})
+      coercer = options.fetch(:configured_coercer){ Virtus.coercer }
+      Coercer.new(coercer, coercion_method)
+    end
+
+    # Return default reader class
+    #
+    # @return [::Class]
+    #
+    # @api private
+    def self.reader_class(*)
+      Reader
+    end
+
+    # Return default writer class
+    #
+    # @param [::Class] attribute type
+    # @param [::Hash] attribute options
+    #
+    # @return [::Class]
+    #
+    # @api private
+    def self.writer_class(type, options)
+      coerce = options.fetch(:coerce){ Virtus.coerce }
+      coerce ? coercible_writer_class(type, options) : Writer
+    end
+
+    # Return default coercible writer class
+    #
+    # @param [::Class] attribute type
+    # @param [::Hash] attribute options
+    #
+    # @return [::Class]
+    #
+    # @api private
+    def self.coercible_writer_class(_type, _options)
+      Writer::Coercible
+    end
+
+    # Return default options for writer class
+    #
+    # @return [::Hash]
+    #
+    # @api private
+    def self.reader_options(*)
+      {}
+    end
+
+    # Return options accepted by writer class
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    def self.writer_options(attribute_options)
+      ::Hash[writer_option_names.zip(attribute_options.values_at(*writer_option_names))]
+    end
+
+    # Return acceptable option names for write class
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    def self.writer_option_names
+      [ :coercer, :primitive, :default ]
+    end
+
+    # Determine attribute type based on class or name
+    #
+    # Returns Attribute::EmbeddedValue if a virtus class is passed
+    #
+    # @example
+    #   address_class = Class.new { include Virtus }
+    #   Virtus::Attribute.determine_type(address_class) # => Virtus::Attribute::EmbeddedValue
+    #
+    # @see Virtus::Support::TypeLookup.determine_type
+    #
+    # @return [Class]
+    #
+    # @api public
+    def self.determine_type(class_or_name)
+      case class_or_name
+      when ::Class
+        EmbeddedValue.determine_type(class_or_name) or super
+      when ::String
+        super
+      when ::Enumerable
+        super(class_or_name.class)
+      else
+        super
+      end
+    end
+
+    # A hook for Attributes to update options based on the type from the caller
+    #
+    # @param [Object] type
+    #   The raw type, typically given by the caller of ClassMethods#attribute
+    # @param [Hash] options
+    #   Attribute configuration options
+    #
+    # @return [Hash]
+    #   New Hash instance, potentially updated with information from the args
+    #
+    # @api private
+    def self.merge_options(type, options)
+      merged_options = self.options.merge(options)
+
+      if merged_options[:coerce]
+        merged_options.update(
+          :coercer => merged_options.fetch(:coercer) { coercer(type, options) }
+        )
+      end
+
+      merged_options
+    end
+
+    # Initializes an attribute instance
+    #
+    # @param [#to_sym] name
+    #   the name of an attribute
+    #
+    # @param [#to_hash] options
+    #   hash of extra options which overrides defaults set on an attribute class
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(name, accessor)
+      @name     = name.to_sym
+      @accessor = accessor
+    end
+
+    # Return reader object
+    #
+    # @example
+    #
+    #   attribute.reader # => #<Virtus::Attribute::Reader ...>
+    #
+    # @return [Reader]
+    #
+    # @api public
+    def reader
+      accessor.reader
+    end
+
+    # Return writer object
+    #
+    # @example
+    #
+    #   attribute.writer # => #<Virtus::Attribute::Writer ...>
+    #
+    # @return [Writer]
+    #
+    # @api public
+    def writer
+      accessor.writer
+    end
+
+    # Define reader and writer methods for an Attribute
+    #
+    # @param [AttributeSet] mod
+    #
+    # @return [self]
+    #
+    # @api private
+    def define_accessor_methods(attribute_set)
+      reader.define_method(accessor, attribute_set)
+      writer.define_method(accessor, attribute_set)
+      self
+    end
+
+    # Returns a Boolean indicating whether the reader method is public
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def public_reader?
+      accessor.public_reader?
+    end
+
+    # Returns a Boolean indicating whether the writer method is public
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def public_writer?
+      accessor.public_writer?
+    end
+
+    # Returns if the given value is coerced into the target type
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def value_coerced?(value)
+      coercer.coerced?(value)
+    end
+
+    private
+
+    # Return coercer for this attribute
+    #
+    # @return [Object]
+    #
+    # @api private
+    def coercer
+      writer.coercer[self.class.primitive]
+    end
+
+  end # class Attribute
+
+end # module Virtus

data/lib/project/attribute_set.rb

@@ -0,0 +1,260 @@
+module Virtus
+
+  class AS
+    include Enumerable
+
+    def initialize(parent = nil, attributes = [])
+      @parent = parent
+      @attributes = attributes
+      @index = {}
+      reset
+    end
+
+  def each
+      return to_enum unless block_given?
+      @index.values.uniq.each { |attribute| yield attribute }
+      self
+    end
+
+  end
+
+  module AttributeSet
+
+    def self.new(parent = nil, attributes = [])
+      Module.new.tap do |m|
+        m.module_eval do
+          extend Implementation
+          @parent = parent
+          @attributes = attributes
+          @index = {}
+          reset
+        end
+      end
+    end
+
+    module Implementation
+      include Enumerable
+
+      def inspect
+        "#<#{AttributeSet.name}:0x#{ '%x' % (object_id << 1) }>"
+      end
+
+      # Initialize an AttributeSet
+      #
+      # @param [AttributeSet] parent
+      # @param [Array] attributes
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(parent = nil, attributes = [])
+        @parent     = parent
+        @attributes = attributes.dup
+        @index      = {}
+        reset
+      end
+
+      # Iterate over each attribute in the set
+      #
+      # @example
+      #   attribute_set = AttributeSet.new(attributes, parent)
+      #   attribute_set.each { |attribute| ... }
+      #
+      # @yield [attribute]
+      #
+      # @yieldparam [Attribute] attribute
+      #   each attribute in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        return to_enum unless block_given?
+        @index.values.uniq.each { |attribute| yield attribute }
+        self
+      end
+
+      # Adds the attributes to the set
+      #
+      # @example
+      #   attribute_set.merge(attributes)
+      #
+      # @param [Array<Attribute>] attributes
+      #
+      # @return [self]
+      #
+      # @api public
+      def merge(attributes)
+        attributes.each { |attribute| self << attribute }
+        self
+      end
+
+      # Adds an attribute to the set
+      #
+      # @example
+      #   attribute_set << attribute
+      #
+      # @param [Attribute] attribute
+      #
+      # @return [self]
+      #
+      # @api public
+      def <<(attribute)
+        self[attribute.name] = attribute
+        attribute.define_accessor_methods(self)
+        self
+      end
+
+      # Get an attribute by name
+      #
+      # @example
+      #   attribute_set[:name]  # => Attribute object
+      #
+      # @param [Symbol] name
+      #
+      # @return [Attribute]
+      #
+      # @api public
+      def [](name)
+        @index[name]
+      end
+
+      # Set an attribute by name
+      #
+      # @example
+      #   attribute_set[:name] = attribute
+      #
+      # @param [Symbol] name
+      # @param [Attribute] attribute
+      #
+      # @return [Attribute]
+      #
+      # @api public
+      def []=(name, attribute)
+        @attributes << attribute
+        update_index(name, attribute)
+      end
+
+      # Reset the index when the parent is updated
+      #
+      # @return [self]
+      #
+      # @api private
+      def reset
+        merge_attributes(@parent) if @parent
+        merge_attributes(@attributes)
+        self
+      end
+
+      # Defines an attribute reader method
+      #
+      # @param [Attribute] attribute
+      # @param [Symbol] method_name
+      # @param [Symbol] visibility
+      #
+      # @return [self]
+      #
+      # @api private
+      def define_reader_method(attribute, method_name, visibility)
+        define_method(method_name) { attribute.get(self) }
+        send(visibility, method_name)
+        self
+      end
+
+      # Defines an attribute writer method
+      #
+      # @param [Attribute] attribute
+      # @param [Symbol] method_name
+      # @param [Symbol] visibility
+      #
+      # @return [self]
+      #
+      # @api private
+      def define_writer_method(attribute, method_name, visibility)
+        define_method(method_name) { |value| attribute.set(self, value) }
+        send(visibility, method_name)
+        self
+      end
+
+      # Get values of all attributes defined for this class, ignoring privacy
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def get(object, &block)
+        each_with_object({}) do |attribute, attributes|
+          name = attribute.name
+          attributes[name] = object.__send__(name) if yield(attribute)
+        end
+      end
+
+      # Mass-assign attribute values
+      #
+      # @see Virtus::InstanceMethods#attributes=
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def set(object, attributes)
+        coerce(attributes).each do |name, value|
+          writer_name = "#{name}="
+          if object.allowed_writer_methods.include?(writer_name)
+            object.__send__(writer_name, value)
+          end
+        end
+      end
+
+      # Set default attributes
+      #
+      # @return [self]
+      #
+      # @api private
+      def set_defaults(object)
+        each do |attribute|
+          if object.instance_variable_defined?(attribute.reader.instance_variable_name) || attribute.accessor.lazy?
+            next
+          end
+          attribute.writer.set_default_value(object, attribute)
+        end
+      end
+
+      # Coerce attributes received to a hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def coerce(attributes)
+        ::Hash.try_convert(attributes) or raise(
+          NoMethodError, "Expected #{attributes.inspect} to respond to #to_hash"
+        )
+      end
+
+    private
+
+      # Merge the attributes into the index
+      #
+      # @param [Array<Attribute>] attributes
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def merge_attributes(attributes)
+        attributes.each { |attribute| update_index(attribute.name, attribute) }
+      end
+
+      # Update the symbol and string indexes with the attribute
+      #
+      # @param [Symbol] name
+      #
+      # @param [Attribute] attribute
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def update_index(name, attribute)
+        @index[name] = @index[name.to_s.freeze] = attribute
+      end
+
+    end # Implementation
+  end # AttributeSet
+end # module Virtus

data/lib/project/class_inclusions.rb

@@ -0,0 +1,41 @@
+module Virtus
+
+  # Class-level extensions
+  module ClassInclusions
+
+    # Extends a descendant with class and instance methods
+    #
+    # @param [Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.included(descendant)
+      super
+      descendant.extend(ClassMethods)
+      descendant.class_eval { include InstanceMethods }
+    end
+    private_class_method :included
+
+    # Return a list of allowed writer method names
+    #
+    # @return [Set]
+    #
+    # @api private
+    def allowed_writer_methods
+      self.class.allowed_writer_methods
+    end
+
+  private
+
+    # Return class' attribute set
+    #
+    # @return [Virtus::AttributeSet]
+    #
+    # @api private
+    def attribute_set
+      self.class.send(:attribute_set)
+    end
+
+  end # module ClassInclusions
+end # module Virtus

data/lib/project/class_methods.rb

@@ -0,0 +1,102 @@
+module Virtus
+
+  # Class methods that are added when you include Virtus
+  module ClassMethods
+    include Extensions
+    include ConstMissingExtensions
+
+    # Hook called when module is extended
+    #
+    # @param [Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.extended(descendant)
+      super
+      descendant.module_eval do
+        extend DescendantsTracker
+        include attribute_set
+      end
+    end
+
+    private_class_method :extended
+
+    # Returns all the attributes defined on a Class
+    #
+    # @example
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :name, String
+    #     attribute :age,  Integer
+    #   end
+    #
+    #   User.attribute_set  # =>
+    #
+    #   TODO: implement inspect so the output is not cluttered - solnic
+    #
+    # @return [AttributeSet]
+    #
+    # @api public
+    def attribute_set
+      return @attribute_set if defined?(@attribute_set)
+      superclass  = self.superclass
+      method      = __method__
+      parent      = superclass.public_send(method) if superclass.respond_to?(method)
+      @attribute_set = AttributeSet.new(parent)
+    end
+
+    # @see Virtus::ClassMethods.attribute_set
+    #
+    # @deprecated
+    #
+    # @api public
+    def attributes
+      warn "#{self}.attributes is deprecated. Use #{self}.attribute_set instead: #{caller.first}"
+      attribute_set
+    end
+
+  private
+
+    # Setup descendants' own Attribute-accessor-method-hosting modules
+    #
+    # Descendants inherit Attribute accessor methods via Ruby's inheritance
+    # mechanism: Attribute accessor methods are defined in a module included
+    # in a superclass. Attributes defined on descendants add methods to the
+    # descendant's Attributes accessor module, leaving the superclass's method
+    # table unaffected.
+    #
+    # @param [Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def inherited(descendant)
+      super
+      descendant.module_eval { include attribute_set }
+    end
+
+    # Add the attribute to the class' and descendants' attributes
+    #
+    # @param [Attribute] attribute
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def virtus_add_attribute(attribute)
+      super
+      descendants.each { |descendant| descendant.attribute_set.reset }
+    end
+
+    # The list of allowed public methods
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    def allowed_methods
+      public_instance_methods.map(&:to_s)
+    end
+
+  end # module ClassMethods
+end # module Virtus