virtus2 2.0.1

data/Rakefile

@@ -0,0 +1,15 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task default: [:spec]
+
+begin
+  require "rubocop/rake_task"
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << "--display-cop-names"
+  end
+rescue LoadError
+end

data/TODO.md

@@ -0,0 +1,6 @@
+1.0.0.rc ROADMAP:
+
+  - Refactor to use soon-to-be-extracted axiom-types
+  - Add ability to pass in custom reader/writer *objects*
+  - Refactor to use extracted equalizer gem
+  - Tune Adamantium usage to memoize common methods in Attribute

data/lib/virtus/attribute/accessor.rb

@@ -0,0 +1,103 @@
+module Virtus
+  class Attribute
+
+    # Accessor extension provides methods to read and write attributes
+    #
+    # @example
+    #
+    #   attribute = Virtus::Attribute.build(String, :name => :email)
+    #   model     = Class.new { attr_reader :email }
+    #   object    = model.new
+    #
+    #   attribute.set(object, 'jane@doe.com')
+    #   attribute.get(object) # => 'jane@doe.com'
+    #
+    module Accessor
+
+      # Return name of this accessor attribute
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      attr_reader :name
+
+      # Return instance_variable_name used by this accessor
+      #
+      # @api private
+      attr_reader :instance_variable_name
+
+      # @api private
+      def self.extended(descendant)
+        super
+        name = descendant.options.fetch(:name).to_sym
+        descendant.instance_variable_set('@name', name)
+        descendant.instance_variable_set('@instance_variable_name', "@#{name}")
+      end
+
+      # Return if attribute value is defined
+      #
+      # @param [Object] instance
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def defined?(instance)
+        instance.instance_variable_defined?(instance_variable_name)
+      end
+
+      # Return value of the attribute
+      #
+      # @param [Object] instance
+      #
+      # @return [Object]
+      #
+      # @api public
+      def get(instance)
+        instance.instance_variable_get(instance_variable_name)
+      end
+
+      # Set value of the attribute
+      #
+      # @param [Object] instance
+      # @param [Object] value
+      #
+      # @return [Object] value that was set
+      #
+      # @api public
+      def set(instance, value)
+        instance.instance_variable_set(instance_variable_name, value)
+      end
+
+      # Set default value
+      #
+      # @param [Object] instance
+      #
+      # @return [Object] value that was set
+      #
+      # @api public
+      def set_default_value(instance)
+        set(instance, default_value.call(instance, self))
+      end
+
+      # Returns a Boolean indicating whether the reader method is public
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def public_reader?
+        options[:reader] == :public
+      end
+
+      # Returns a Boolean indicating whether the writer method is public
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def public_writer?
+        options[:writer] == :public
+      end
+
+    end # Accessor
+
+  end # Attribute
+end # Virtus

data/lib/virtus/attribute/boolean.rb

@@ -0,0 +1,55 @@
+module Virtus
+  class Attribute
+
+    # Boolean attribute allows true or false values to be set
+    # Additionally it adds boolean reader method, like "admin?"
+    #
+    # @example
+    #   class Post
+    #     include Virtus
+    #
+    #     attribute :published, Boolean
+    #   end
+    #
+    #   post = Post.new(:published => false)
+    #   post.published?  # => false
+    #
+    class Boolean < Attribute
+      primitive TrueClass
+
+      # @api private
+      def self.build_type(*)
+        Axiom::Types::Boolean
+      end
+
+      # Returns if the given value is either true or false
+      #
+      # @example
+      #   boolean = Virtus::Attribute::Boolean.new(:bool)
+      #   boolean.value_coerced?(true)    # => true
+      #   boolean.value_coerced?(false)   # => true
+      #   boolean.value_coerced?(1)       # => false
+      #   boolean.value_coerced?('true')  # => false
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def value_coerced?(value)
+        value.equal?(true) || value.equal?(false)
+      end
+
+      # Creates an attribute reader method as a query
+      #
+      # @param [Module] mod
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def define_accessor_methods(attribute_set)
+        super
+        attribute_set.define_reader_method(self, "#{name}?", options[:reader])
+      end
+
+    end # class Boolean
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/builder.rb

@@ -0,0 +1,182 @@
+module Virtus
+
+  # Attribute placeholder used when type constant is passed as a string or symbol
+  #
+  # @private
+  class PendingAttribute
+    attr_reader :type, :options, :name
+
+    # @api private
+    def initialize(type, options)
+      @type, @options = type.to_s, 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?('::')
+        Virtus.constantize(type)
+      else
+        Object.const_get(type)
+      end
+    end
+
+  end # PendingAttribute
+
+  # Extracts the actual type primitive from input type
+  #
+  # @private
+  class TypeDefinition
+    attr_reader :type, :primitive
+
+    # @api private
+    def initialize(type)
+      @type = type
+      initialize_primitive
+    end
+
+    # @api private
+    def pending?
+      @pending if defined?(@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
+
+    # Builder is used to set up an attribute instance based on input type and options
+    #
+    # @private
+    class Builder
+      attr_reader :attribute, :options, :type_definition, :klass, :type
+
+      # @api private
+      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
+      def self.determine_type(klass, default = nil)
+        type = Attribute.determine_type(klass)
+
+        if klass.is_a?(Class)
+          type ||=
+            if klass < Axiom::Types::Type
+              determine_type(klass.primitive)
+            elsif EmbeddedValue.handles?(klass)
+              EmbeddedValue
+            elsif klass < Enumerable && !(klass <= Range)
+              Collection
+            end
+        end
+
+        type || default
+      end
+
+      # @api private
+      def initialize(type_definition, options)
+        @type_definition = type_definition
+
+        initialize_class
+        initialize_type
+        initialize_options(options)
+        initialize_default_value
+        initialize_coercer
+        initialize_attribute
+      end
+
+      private
+
+      # @api private
+      def initialize_class
+        @klass = self.class.determine_type(type_definition.primitive, Attribute)
+      end
+
+      # @api private
+      def initialize_type
+        @type = klass.build_type(type_definition)
+      end
+
+      # @api private
+      def initialize_options(options)
+        @options = klass.options.merge(:coerce => Virtus.coerce).update(options)
+        klass.merge_options!(type, @options)
+        determine_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 => determine_coercer)
+      end
+
+      # @api private
+      def initialize_attribute
+        @attribute = klass.new(type, options)
+
+        @attribute.extend(Accessor)     if options[:name]
+        @attribute.extend(Coercible)    if options[:coerce]
+        @attribute.extend(NullifyBlank) if options[:nullify_blank]
+        @attribute.extend(Strict)       if options[:strict]
+        @attribute.extend(LazyDefault)  if options[:lazy]
+
+        @attribute.finalize if options[:finalize]
+      end
+
+      # @api private
+      def determine_coercer
+        options.fetch(:coercer) { klass.build_coercer(type, options) }
+      end
+
+      # @api private
+      def determine_visibility
+        default_accessor  = options.fetch(:accessor)
+        reader_visibility = options.fetch(:reader, default_accessor)
+        writer_visibility = options.fetch(:writer, default_accessor)
+        options.update(:reader => reader_visibility, :writer => writer_visibility)
+      end
+
+    end # class Builder
+
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/coercer.rb

@@ -0,0 +1,45 @@
+module Virtus
+  class Attribute
+
+    # Coercer accessor wrapper
+    #
+    # @api private
+    class Coercer < Virtus::Coercer
+
+      # @api private
+      attr_reader :method, :coercers
+
+      # Initialize a new coercer object
+      #
+      # @param [Object] coercers accessor
+      # @param [Symbol] coercion method
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(type, coercers)
+        super(type)
+        @method   = type.coercion_method
+        @coercers = coercers
+      end
+
+      # Coerce given value
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call(value)
+        coercers[value.class].public_send(method, value)
+      rescue ::Coercible::UnsupportedCoercion
+        value
+      end
+
+      # @api public
+      def success?(primitive, value)
+        coercers[primitive].coerced?(value)
+      end
+
+    end # class Coercer
+
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/coercible.rb

@@ -0,0 +1,20 @@
+module Virtus
+  class Attribute
+
+    # Attribute extension providing coercion when setting an attribute value
+    #
+    module Coercible
+
+      # Coerce value before setting
+      #
+      # @see Accessor#set
+      #
+      # @api public
+      def set(instance, value)
+        super(instance, coerce(value))
+      end
+
+    end # Coercible
+
+  end # Attribute
+end # Virtus

data/lib/virtus/attribute/collection.rb

@@ -0,0 +1,103 @@
+module Virtus
+  class Attribute
+
+    # Collection attribute handles enumerable-like types
+    #
+    # Handles coercing members to the designated member type.
+    #
+    class Collection < Attribute
+      default Proc.new { |_, attribute| attribute.primitive.new }
+
+      # @api private
+      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 axiom_type?(type)
+
+          klass  = Axiom::Types.infer(type)
+          member = infer_member_type(type) || Object
+
+          if EmbeddedValue.handles?(member) || pending?(member)
+            Type.new(primitive, member)
+          else
+            klass.new {
+              primitive primitive
+              member_type Axiom::Types.infer(member)
+            }
+          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)
+
+          member_type =
+            if type.count > 1
+              raise NotImplementedError, "build SumType from list of types (#{type})"
+            else
+              type.first
+            end
+
+          if member_type.is_a?(Class) && member_type < Attribute && member_type.primitive
+            member_type.primitive
+          else
+            member_type
+          end
+        end
+
+        def coercion_method
+          :to_array
+        end
+      end
+
+      # @api private
+      def self.build_type(definition)
+        Type.infer(definition.type, definition.primitive)
+      end
+
+      # @api private
+      def self.merge_options!(type, options)
+        options[:member_type] ||= Attribute.build(type.member_type, strict: options[:strict])
+      end
+
+      # @api public
+      def coerce(value)
+        coerced = super
+
+        return coerced unless coerced.respond_to?(:each_with_object)
+
+        coerced.each_with_object(primitive.new) do |entry, collection|
+          collection << member_type.coerce(entry)
+        end
+      end
+
+      # @api public
+      def value_coerced?(value)
+        super && value.all? { |item| member_type.value_coerced? item }
+      end
+
+      # @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