virtus2 2.0.1

data/lib/virtus/attribute/default_value/from_callable.rb

@@ -0,0 +1,35 @@
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a callable object
+      #
+      # @api private
+      class FromCallable < DefaultValue
+
+        # Return if the class can handle the value
+        #
+        # @param [Object] value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(value)
+          value.respond_to?(:call)
+        end
+
+        # Evaluates the value via value#call
+        #
+        # @param [Object] args
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def call(*args)
+          @value.call(*args)
+        end
+
+      end # class FromCallable
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/default_value/from_clonable.rb

@@ -0,0 +1,35 @@
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a clonable object
+      #
+      # @api private
+      class FromClonable < DefaultValue
+        SINGLETON_CLASSES = [
+          ::NilClass, ::TrueClass, ::FalseClass, ::Numeric,  ::Symbol ].freeze
+
+        # Return if the class can handle the value
+        #
+        # @param [Object] value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(value)
+          SINGLETON_CLASSES.none? { |klass| value.kind_of?(klass) }
+        end
+
+        # Evaluates the value via value#clone
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def call(*)
+          @value.clone
+        end
+
+      end # class FromClonable
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/default_value/from_symbol.rb

@@ -0,0 +1,35 @@
+module Virtus
+  class Attribute
+    class DefaultValue
+
+      # Represents default value evaluated via a symbol
+      #
+      # @api private
+      class FromSymbol < DefaultValue
+
+        # Return if the class can handle the value
+        #
+        # @param [Object] value
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def self.handle?(value)
+          value.is_a?(Symbol)
+        end
+
+        # Evaluates the value via instance#public_send(value)
+        #
+        # Symbol value is returned if the instance doesn't respond to value
+        #
+        # @return [Object] evaluated value
+        #
+        # @api private
+        def call(instance, _)
+          instance.respond_to?(@value, true) ? instance.send(@value) : @value
+        end
+
+      end # class FromSymbol
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/default_value.rb

@@ -0,0 +1,51 @@
+module Virtus
+  class Attribute
+
+    # Class representing the default value option
+    #
+    # @api private
+    class DefaultValue
+      extend DescendantsTracker
+
+      include Equalizer.new(inspect) << :value
+
+      # Builds a default value instance
+      #
+      # @return [Virtus::Attribute::DefaultValue]
+      #
+      # @api private
+      def self.build(*args)
+        klass = descendants.detect { |descendant| descendant.handle?(*args) } || self
+        klass.new(*args)
+      end
+
+      # Returns the value instance
+      #
+      # @return [Object]
+      #
+      # @api private
+      attr_reader :value
+
+      # Initializes an default value instance
+      #
+      # @param [Object] value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(value)
+        @value = value
+      end
+
+      # Evaluates the value
+      #
+      # @return [Object] evaluated value
+      #
+      # @api private
+      def call(*)
+        value
+      end
+
+    end # class DefaultValue
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/embedded_value.rb

@@ -0,0 +1,67 @@
+module Virtus
+  class Attribute
+
+    # EmbeddedValue handles virtus-like objects, OpenStruct and Struct
+    #
+    class EmbeddedValue < Attribute
+      TYPES = [Struct, OpenStruct, Virtus, Model::Constructor].freeze
+
+      # Builds Struct-like instance with attributes passed to the constructor as
+      # a list of args rather than a hash
+      #
+      # @private
+      class FromStruct < Virtus::Coercer
+
+        # @api public
+        def call(input)
+          if input.kind_of?(primitive)
+            input
+          elsif not input.nil?
+            primitive.new(*input)
+          end
+        end
+
+      end # FromStruct
+
+      # Builds OpenStruct-like instance with attributes passed to the constructor
+      # as a hash
+      #
+      # @private
+      class FromOpenStruct < Virtus::Coercer
+
+        # @api public
+        def call(input)
+          if input.kind_of?(primitive)
+            input
+          elsif not input.nil?
+            primitive.new(input)
+          end
+        end
+
+      end # FromOpenStruct
+
+      # @api private
+      def self.handles?(klass)
+        klass.is_a?(Class) && TYPES.any? { |type| klass <= type }
+      end
+
+      # @api private
+      def self.build_type(definition)
+        Axiom::Types::Object.new { primitive definition.primitive }
+      end
+
+      # @api private
+      def self.build_coercer(type, _options)
+        primitive = type.primitive
+
+        if primitive < Virtus || primitive < Model::Constructor || primitive <= OpenStruct
+          FromOpenStruct.new(type)
+        elsif primitive < Struct
+          FromStruct.new(type)
+        end
+      end
+
+    end # class EmbeddedValue
+
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/enum.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Virtus
+  class Attribute
+
+    # Type to be used inside attributes as enums.
+    # @example
+    #     class Event < Quiver::BaseModel
+    #       attribute :mode, Quiver::Types::Enum[:read, :write]
+    #     end
+    class Enum < Attribute
+
+      primitive Axiom::Types::Symbol
+
+      class << self
+
+        attr_accessor :values
+
+        # @param values [Array<Symbol>]
+        def [](*values)
+          klass = Class.new(self)
+          klass.values = values
+          klass
+        end
+
+        # :nodoc:
+        def build_type(*)
+          Axiom::Types::Symbol
+        end
+
+      end
+
+      def coercion_error_message
+        "Enum (#{self.class.values.join(',')})"
+      end
+
+      # @param value [Object]
+      # @return [Boolean]
+      def value_coerced?(value)
+        self.class.values.include?(value)
+      end
+
+    end
+  end
+end

data/lib/virtus/attribute/hash.rb

@@ -0,0 +1,130 @@
+module Virtus
+  class Attribute
+
+    # Handles attributes with Hash type
+    #
+    class Hash < Attribute
+      primitive ::Hash
+      default   primitive.new
+
+      # @api private
+      attr_reader :key_type, :value_type
+
+      # FIXME: remove this once axiom-types supports it
+      #
+      # @private
+      Type = Struct.new(:key_type, :value_type) do
+        def self.infer(type)
+          if axiom_type?(type)
+            new(type.key_type, type.value_type)
+          else
+            type_options = infer_key_and_value_types(type)
+            key_class    = determine_type(type_options.fetch(:key_type,   Object))
+            value_class  = determine_type(type_options.fetch(:value_type, Object))
+
+            new(key_class, value_class)
+          end
+        end
+
+        # @api private
+        def self.pending?(primitive)
+          primitive.is_a?(String) || primitive.is_a?(Symbol)
+        end
+
+        # @api private
+        def self.axiom_type?(type)
+          type.is_a?(Class) && type < Axiom::Types::Type
+        end
+
+        # @api private
+        def self.determine_type(type)
+          return type if pending?(type)
+
+          if EmbeddedValue.handles?(type)
+            type
+          else
+            Axiom::Types.infer(type)
+          end
+        end
+
+        # @api private
+        def self.infer_key_and_value_types(type)
+          return {} unless type.kind_of?(::Hash)
+
+          if type.size > 1
+            raise ArgumentError, "more than one [key => value] pair in `#{type}`"
+          else
+            key_type, value_type = type.keys.first, type.values.first
+
+            key_primitive =
+              if key_type.is_a?(Class) && key_type < Attribute && key_type.primitive
+                key_type.primitive
+              else
+                key_type
+              end
+
+            value_primitive =
+              if value_type.is_a?(Class) && value_type < Attribute && value_type.primitive
+                value_type.primitive
+              else
+                value_type
+              end
+
+            { :key_type => key_primitive, :value_type => value_primitive}
+          end
+        end
+
+        # @api private
+        def coercion_method
+          :to_hash
+        end
+
+        # @api private
+        def primitive
+          ::Hash
+        end
+      end
+
+      # @api private
+      def self.build_type(definition)
+        Type.infer(definition.type)
+      end
+
+      # @api private
+      def self.merge_options!(type, options)
+        options[:key_type]   ||= Attribute.build(type.key_type, :strict => options[:strict])
+        options[:value_type] ||= Attribute.build(type.value_type, :strict => options[:strict])
+      end
+
+      # Coerce members
+      #
+      # @see [Attribute#coerce]
+      #
+      # @api public
+      def coerce(*)
+        coerced = super
+
+        return coerced unless coerced.respond_to?(:each_with_object)
+
+        coerced.each_with_object({}) do |(key, value), hash|
+          hash[key_type.coerce(key)] = value_type.coerce(value)
+        end
+      end
+
+      # @api private
+      def finalize
+        return self if finalized?
+        @key_type   = options[:key_type].finalize
+        @value_type = options[:value_type].finalize
+        super
+      end
+
+      # @api private
+      def finalized?
+        super && key_type.finalized? && value_type.finalized?
+      end
+
+    end # class Hash
+
+  end # class Attribute
+end # module Virtus

data/lib/virtus/attribute/lazy_default.rb

@@ -0,0 +1,18 @@
+module Virtus
+  class Attribute
+
+    module LazyDefault
+
+      # @api public
+      def get(instance)
+        if instance.instance_variable_defined?(instance_variable_name)
+          super
+        else
+          set_default_value(instance)
+        end
+      end
+
+    end # LazyDefault
+
+  end # Attribute
+end # Virtus

data/lib/virtus/attribute/nullify_blank.rb

@@ -0,0 +1,24 @@
+module Virtus
+  class Attribute
+
+    # Attribute extension which nullifies blank attributes when coercion failed
+    #
+    module NullifyBlank
+
+      # @see [Attribute#coerce]
+      #
+      # @api public
+      def coerce(input)
+        output = super
+
+        if !value_coerced?(output) && input.to_s.empty?
+          nil
+        else
+          output
+        end
+      end
+
+    end # NullifyBlank
+
+  end # Attribute
+end # Virtus