virtus2 2.0.1

data/lib/virtus/extensions.rb

@@ -0,0 +1,105 @@
+module Virtus
+
+  # Extensions common for both classes and instances
+  module Extensions
+    WRITER_METHOD_REGEXP   = /=\z/.freeze
+    INVALID_WRITER_METHODS = %w[ == != === []= attributes= ].to_set.freeze
+    RESERVED_NAMES         = [:attributes].to_set.freeze
+
+    # A hook called when an object is extended with Virtus
+    #
+    # @param [Object] object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def self.extended(object)
+      super
+      object.instance_eval do
+        extend Methods
+        extend InstanceMethods
+        extend InstanceMethods::MassAssignment
+      end
+    end
+    private_class_method :extended
+
+    module Methods
+
+      # @api private
+      def self.extended(descendant)
+        super
+        descendant.extend(AttributeSet.create(descendant))
+      end
+      private_class_method :extended
+
+      # Defines an attribute on an object's class or instance
+      #
+      # @example
+      #    class Book
+      #      include Virtus.model
+      #
+      #      attribute :title,        String
+      #      attribute :author,       String
+      #      attribute :published_at, DateTime
+      #      attribute :page_count,   Integer
+      #      attribute :index                   # defaults to Object
+      #    end
+      #
+      # @param [Symbol] name
+      #   the name of an attribute
+      #
+      # @param [Class,Array,Hash,Axiom::Types::Type,String,Symbol] type
+      #   the type class of an attribute
+      #
+      # @param [#to_hash] options
+      #   the extra options hash
+      #
+      # @return [self]
+      #
+      # @see Attribute.build
+      #
+      # @api public
+      def attribute(name, type = nil, options = {})
+        assert_valid_name(name)
+        attribute_set << Attribute.build(type, options.merge(:name => name))
+        self
+      end
+
+      # @see Virtus.default_value
+      #
+      # @api public
+      def values(&block)
+        private :attributes= if instance_methods.include?(:attributes=)
+        yield
+        include(Equalizer.new(name, attribute_set.map(&:name)))
+      end
+
+      # The list of writer methods that can be mass-assigned to in #attributes=
+      #
+      # @return [Set]
+      #
+      # @api private
+      def allowed_writer_methods
+        @allowed_writer_methods ||=
+          begin
+            allowed_writer_methods  = allowed_methods.grep(WRITER_METHOD_REGEXP).to_set
+            allowed_writer_methods -= INVALID_WRITER_METHODS
+            allowed_writer_methods.freeze
+          end
+      end
+
+      private
+
+      # Return an attribute set for that instance
+      #
+      # @return [AttributeSet]
+      #
+      # @api private
+      def attribute_set
+        @attribute_set
+      end
+
+    end # Methods
+
+  end # module Extensions
+end # module Virtus

data/lib/virtus/instance_methods.rb

@@ -0,0 +1,218 @@
+module Virtus
+
+  # Instance methods that are added when you include Virtus
+  module InstanceMethods
+
+    module Constructor
+
+      # Set attributes during initialization of an object
+      #
+      # @param [#to_hash] attributes
+      #   the attributes hash to be set
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(attributes = nil)
+        attribute_set.set(self, attributes) if attributes
+        set_default_attributes
+      end
+
+    end # Constructor
+
+    module MassAssignment
+
+      # Returns a hash of all publicly accessible attributes
+      #
+      # @example
+      #   class User
+      #     include Virtus
+      #
+      #     attribute :name, String
+      #     attribute :age,  Integer
+      #   end
+      #
+      #   user = User.new(:name => 'John', :age => 28)
+      #   user.attributes  # => { :name => 'John', :age => 28 }
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def attributes
+        attribute_set.get(self)
+      end
+      alias_method :to_hash, :attributes
+      alias_method :to_h, :attributes
+
+      # Mass-assign attribute values
+      #
+      # Keys in the +attributes+ param can be symbols or strings.
+      # All referenced Attribute writer methods *will* be called.
+      # Non-attribute setter methods on the receiver *will* be called.
+      #
+      # @example
+      #   class User
+      #     include Virtus
+      #
+      #     attribute :name, String
+      #     attribute :age,  Integer
+      #   end
+      #
+      #   user = User.new
+      #   user.attributes = { :name => 'John', 'age' => 28 }
+      #
+      # @param [#to_hash] attributes
+      #   a hash of attribute names and values to set on the receiver
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def attributes=(attributes)
+        attribute_set.set(self, attributes)
+      end
+
+    end # MassAssignment
+
+    # Returns a value of the attribute with the given name
+    #
+    # @example
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :name, String
+    #   end
+    #
+    #   user = User.new(:name => 'John')
+    #   user[:name]  # => "John"
+    #
+    # @param [Symbol] name
+    #   a name of an attribute
+    #
+    # @return [Object]
+    #   a value of an attribute
+    #
+    # @api public
+    def [](name)
+      public_send(name)
+    end
+
+    # Sets a value of the attribute with the given name
+    #
+    # @example
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :name, String
+    #   end
+    #
+    #   user = User.new
+    #   user[:name] = "John"  # => "John"
+    #   user.name             # => "John"
+    #
+    # @param [Symbol] name
+    #   a name of an attribute
+    #
+    # @param [Object] value
+    #   a value to be set
+    #
+    # @return [Object]
+    #   the value set on an object
+    #
+    # @api public
+    def []=(name, value)
+      public_send("#{name}=", value)
+    end
+
+    # Freeze object
+    #
+    # @return [self]
+    #
+    # @api public
+    #
+    # @example
+    #
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :name, String
+    #     attribute :age,  Integer
+    #   end
+    #
+    #   user = User.new(:name => 'John', :age => 28)
+    #   user.frozen? # => false
+    #   user.freeze
+    #   user.frozen? # => true
+    #
+    # @api public
+    def freeze
+      set_default_attributes!
+      super
+    end
+
+    # Reset an attribute to its default
+    #
+    # @return [self]
+    #
+    # @api public
+    #
+    # @example
+    #
+    #   class User
+    #     include Virtus
+    #
+    #     attribute :age,  Integer, default: 21
+    #   end
+    #
+    #   user = User.new(:name => 'John', :age => 28)
+    #   user.age = 30
+    #   user.age # => 30
+    #   user.reset_attribute(:age)
+    #   user.age # => 21
+    #
+    # @api public
+    def reset_attribute(attribute_name)
+      attribute = attribute_set[attribute_name]
+      attribute.set_default_value(self) if attribute
+      self
+    end
+
+    # Set default attributes
+    #
+    # @return [self]
+    #
+    # @api private
+    def set_default_attributes
+      attribute_set.set_defaults(self)
+      self
+    end
+
+    # Set default attributes even lazy ones
+    #
+    # @return [self]
+    #
+    # @api public
+    def set_default_attributes!
+      attribute_set.set_defaults(self, proc { |object, attribute| attribute.defined?(object) })
+      self
+    end
+
+    private
+
+    # The list of allowed public methods
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    def allowed_methods
+      public_methods.map(&:to_s)
+    end
+
+    # @api private
+    def assert_valid_name(name)
+      if respond_to?(:attributes) && name.to_sym == :attributes || name.to_sym == :attribute_set
+        raise ArgumentError, "#{name.inspect} is not allowed as an attribute name"
+      end
+    end
+
+  end # module InstanceMethods
+end # module Virtus

data/lib/virtus/model.rb

@@ -0,0 +1,68 @@
+module Virtus
+
+  module Model
+
+    # @api private
+    def self.included(descendant)
+      super
+      descendant.send(:include, ClassInclusions)
+    end
+
+    # @api private
+    def self.extended(descendant)
+      super
+      descendant.extend(Extensions)
+    end
+
+    module Core
+
+      # @api private
+      def self.included(descendant)
+        super
+        descendant.extend(ClassMethods)
+        descendant.send(:include, ClassInclusions::Methods)
+        descendant.send(:include, InstanceMethods)
+      end
+      private_class_method :included
+
+      # @api private
+      def self.extended(descendant)
+        super
+        descendant.extend(Extensions::Methods)
+        descendant.extend(InstanceMethods)
+      end
+      private_class_method :extended
+
+    end # Core
+
+    module Constructor
+
+      # @api private
+      def self.included(descendant)
+        super
+        descendant.send(:include, InstanceMethods::Constructor)
+      end
+      private_class_method :included
+
+    end # Constructor
+
+    module MassAssignment
+
+      # @api private
+      def self.included(descendant)
+        super
+        descendant.send(:include, InstanceMethods::MassAssignment)
+      end
+      private_class_method :included
+
+      # @api private
+      def self.extended(descendant)
+        super
+        descendant.extend(InstanceMethods::MassAssignment)
+      end
+      private_class_method :extended
+
+    end # MassAssignment
+
+  end # Model
+end # Virtus

data/lib/virtus/module_extensions.rb

@@ -0,0 +1,88 @@
+module Virtus
+
+  # Virtus module that can define attributes for later inclusion
+  #
+  # @private
+  module ModuleExtensions
+    include ConstMissingExtensions
+
+    # @api private
+    def self.extended(mod)
+      super
+      setup(mod)
+    end
+
+    # @api private
+    def self.setup(mod, inclusions = [Model], attribute_definitions = [])
+      mod.instance_variable_set('@inclusions', inclusions)
+      existing_attributes = mod.instance_variable_get('@attribute_definitions')
+      new_attributes = (existing_attributes || []) + attribute_definitions
+      mod.instance_variable_set('@attribute_definitions', new_attributes)
+    end
+
+    # Define an attribute in the module
+    #
+    # @see Virtus::Extensions#attribute
+    #
+    # @return [self]
+    #
+    # @api private
+    def attribute(name, type = nil, options = {})
+      @attribute_definitions << [name, type, options]
+      self
+    end
+
+    private
+
+    # Extend an object with Virtus methods and define attributes
+    #
+    # @param [Object] object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def extended(object)
+      super
+      @inclusions.each { |mod| object.extend(mod) }
+      define_attributes(object)
+      object.set_default_attributes
+    end
+
+    # Extend a class with Virtus methods and define attributes
+    #
+    # @param [Object] object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def included(object)
+      super
+
+      if Class === object
+        @inclusions.reject do |mod|
+          object.ancestors.include?(mod)
+        end.each do |mod|
+          object.send(:include, mod)
+        end
+        define_attributes(object)
+      else
+        object.extend(ModuleExtensions)
+        ModuleExtensions.setup(object, @inclusions, @attribute_definitions)
+      end
+    end
+
+    # Define attributes on a class or instance
+    #
+    # @param [Object,Class] object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_attributes(object)
+      @attribute_definitions.each do |attribute_args|
+        object.attribute(*attribute_args)
+      end
+    end
+
+  end # module ModuleExtensions
+end # module Virtus