attributor 2.1.0

data/lib/attributor/types/ids.rb

@@ -0,0 +1,26 @@
+module Attributor
+
+  class Ids < CSV
+
+
+    def self.for(type)
+      identity_name = type.options.fetch(:identity) do
+        raise AttributorException, "no identity found for #{type.name}"
+      end
+
+      identity_attribute = type.attributes.fetch(identity_name) do
+        raise AttributorException, "#{type.name} does not have attribute with name '#{identity_name}'"
+      end
+
+      Class.new(self) do
+        @member_attribute = identity_attribute
+        @member_type = identity_attribute.type
+      end
+
+    end
+
+    def self.of(type)
+      raise "Invalid definition of Ids type. Defining Ids.of(type) is not allowed, you probably meant to do Ids.for(type) instead"
+    end
+  end
+end

data/lib/attributor/types/integer.rb

@@ -0,0 +1,63 @@
+
+
+module Attributor
+
+  class Integer
+    include Type
+
+    EXAMPLE_RANGE = 1000.freeze
+
+    def self.native_type
+      return ::Integer
+    end
+
+
+    def self.example(context=nil, options: {})
+      validate_options(options)
+
+      # Set default values
+      if options[:min].nil? && options[:max].nil?
+        min = 0
+        max = EXAMPLE_RANGE
+      elsif options[:min].nil?
+        max = options[:max]
+        min = max - EXAMPLE_RANGE
+      elsif options[:max].nil?
+        min = options[:min]
+        max = min + EXAMPLE_RANGE
+      else
+        min = options[:min]
+        max = options[:max]
+      end
+
+      # Generate random number on interval [min,max]
+      rand(max-min+1) + min
+    end
+
+    def self.load(value, context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      Integer(value)
+    rescue TypeError
+      super
+    end
+
+    def self.validate_options(options)
+      if options.has_key?(:min) && options.has_key?(:max)
+        # Both :max and :min must be integers
+        raise AttributorException.new("Invalid range: [#{options[:min].inspect}, #{options[:max].inspect}]") if !options[:min].is_a?(::Integer) || !options[:max].is_a?(::Integer)
+
+        # :max cannot be less than :min
+        raise AttributorException.new("Invalid range: [#{options[:min].inspect}, #{options[:max].inspect}]") if options[:max] < options[:min]
+      elsif !options.has_key?(:min) && options.has_key?(:max)
+        # :max must be an integer
+        raise AttributorException.new("Invalid range: [, #{options[:max].inspect}]") if !options[:max].is_a?(::Integer)
+      elsif options.has_key?(:min) && !options.has_key?(:max)
+        # :min must be an integer
+        raise AttributorException.new("Invalid range: [#{options[:min].inspect},]") if !options[:min].is_a?(::Integer)
+      else
+        # Neither :min nor :max were given, noop
+      end
+      true
+    end
+
+  end
+end

data/lib/attributor/types/model.rb

@@ -0,0 +1,316 @@
+module Attributor
+  class Model
+    include Attributor::Type
+    MAX_EXAMPLE_DEPTH = 5
+    CIRCULAR_REFERENCE_MARKER = '...'.freeze
+
+    # FIXME: this is not the way to fix this. Really we should add finalize! to Models.
+    undef :timeout
+    undef :format
+
+
+    def self.inherited(klass)
+      klass.instance_eval do
+        @saved_blocks = []
+        @options = {}
+        @attributes = {}
+      end
+    end
+
+    class << self
+      attr_reader :options
+    end
+
+
+    # Define accessors for attribute of given name.
+    #
+    # @param name [::Symbol] attribute name
+    #
+    def self.define_accessors(name)
+      name = name.to_sym
+      self.define_reader(name)
+      self.define_writer(name)
+    end
+
+
+    def self.define_reader(name)
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}
+          return @attributes[:#{name}] if @attributes.has_key?(:#{name})
+
+          @attributes[:#{name}] = begin
+            if (proc = @lazy_attributes.delete :#{name})
+              if proc.arity > 0
+                proc.call(self)
+              else
+                proc.call
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+
+    def self.define_writer(name)
+      attribute = self.attributes[name]
+      context = ["assignment","of(#{name})"].freeze
+      # note: paradoxically, using define_method ends up being faster for the writer
+      #       attribute is captured by the block, saving us from having to retrieve it from
+      #       the class's attributes hash on each write.
+      module_eval do
+        define_method(name.to_s + "=") do |value|
+          # TODO: what type of context do we report with unscoped assignments?
+          #  => for now this would report "assignment.of(field_name)" is that good?
+          @attributes[name] = attribute.load(value,context)
+        end
+      end
+    end
+
+
+    def self.describe(shallow=false)
+      hash = super
+
+      # Spit attributes if it's the root or if it's an anonymous structures
+      if ( !shallow || self.name == nil) && self.attributes
+        hash[:attributes] = self.attributes.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
+          sub_attributes[sub_name] = sub_attribute.describe(true)
+        end
+      end
+
+      hash
+    end
+
+
+    def self.example(context=nil, **values)
+      result = self.new
+
+      context = case context
+      when nil
+        ["#{self.name}-#{result.object_id.to_s}"]
+      when ::String
+        [context]
+      else
+        context
+      end
+
+      example_depth = context.size
+
+      self.attributes.each do |sub_attribute_name,sub_attribute|
+        if sub_attribute.attributes
+           # TODO: add option to raise an exception in this case?
+           next if example_depth > MAX_EXAMPLE_DEPTH
+        end
+
+        sub_context = self.generate_subcontext(context,sub_attribute_name)
+
+        result.lazy_attributes[sub_attribute_name] = Proc.new do
+          value = values.fetch(sub_attribute_name) do
+            sub_attribute.example(sub_context, parent: result)
+          end
+
+          sub_attribute.load(value,sub_context)
+        end
+      end
+
+      result
+    end
+
+    def self.dump(value, **opts)
+      value.dump(opts)
+    end
+
+    def self.native_type
+      self
+    end
+
+    def self.check_option!(name, value)
+      case name
+      when :identity
+        raise AttributorException, "Invalid identity type #{value.inspect}" unless value.kind_of?(::Symbol)
+        :ok # FIXME ... actually do something smart, that doesn't break lazy attribute creation
+      when :reference
+        :ok # FIXME ... actually do something smart
+      when :dsl_compiler
+        :ok # FIXME ... actually do something smart
+      when :dsl_compiler_options
+        :ok
+      else
+        super
+      end
+    end
+
+
+    # Model-specific decoding and coercion of the attribute.
+    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      return value if value.nil?
+      return value if value.kind_of?(self.native_type)
+
+      context = Array(context)
+
+      hash = case value
+      when ::String
+        # Strings are assumed to be JSON-serialized for now.
+        begin
+          JSON.parse(value)
+        rescue
+          raise DeserializationError, context: context, from: value.class, encoding: "JSON" , value: value
+        end
+      when ::Hash
+        value
+      else
+        raise IncompatibleTypeError,  context: context, value_type: value.class, type: self
+      end
+
+      self.from_hash(hash,context)
+    end
+
+
+    def self.from_hash(hash,context)
+      model = self.new
+
+      self.attributes.each do |attribute_name, attribute|
+        # OPTIMIZE: deleting the keys as we go is mucho faster, but also very risky
+        # Note: use "load" vs. attribute assignment so we can propagate the right context down.
+        sub_context = self.generate_subcontext(context,attribute_name)
+        model.attributes[attribute_name] = attribute.load(hash[attribute_name] || hash[attribute_name.to_s], sub_context)
+      end
+
+      unknown_keys = hash.keys.collect {|k| k.to_sym} - self.attributes.keys
+
+      if unknown_keys.any?
+        raise AttributorException, "Unknown attributes received: #{unknown_keys.inspect} while loading #{Attributor.humanize_context(context)}"
+      end
+
+      model
+    end
+
+    # method to only define the block of attributes for the model
+    # This will be a lazy definition. So we'll only save it in an instance class var for later.
+    def self.attributes(opts={},&block)
+      if block_given?
+        @saved_blocks.push(block)
+        @options.merge!(opts)
+      elsif @saved_blocks.any?
+        self.definition
+      end
+
+      @attributes
+    end
+
+
+    def self.validate(object,context=Attributor::DEFAULT_ROOT_CONTEXT,_attribute)
+      context = [context] if context.is_a? ::String
+
+      unless object.kind_of?(self)
+        raise ArgumentError, "#{self.name} can not validate object of type #{object.class.name} for #{Attributor.humanize_context(context)}."
+      end
+
+      object.validate(context)
+    end
+
+
+    def self.dsl_class
+      @options[:dsl_compiler] || DSLCompiler
+    end
+
+    # Returns the "compiled" definition for the model.
+    # By "compiled" I mean that it will create a new Compiler object with the saved options and saved block that has been passed in the 'attributes' method. This compiled object is memoized (remember, there's one instance of a compiled definition PER MODEL CLASS).
+    # TODO: rework this with Model.finalize! support.
+    def self.definition
+      blocks = @saved_blocks.shift(@saved_blocks.size)
+
+      compiler = dsl_class.new(self, self.options)
+      compiler.parse(*blocks)
+
+      nil
+    end
+
+    attr_reader :lazy_attributes, :validating, :dumping
+
+
+    def initialize( data = nil)
+      @lazy_attributes = ::Hash.new
+      @validating = false
+      @dumping = false
+      if data
+        loaded = self.class.load( data )
+        @attributes = loaded.attributes
+      else
+        @attributes = ::Hash.new
+      end
+    end
+
+
+    # TODO: memoize validation results here, but only after rejiggering how we store the context.
+    #       Two calls to validate() with different contexts should return get the same errors,
+    #       but with their respective contexts.
+    def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
+
+      raise AttributorException, "validation conflict" if @validating
+      @validating = true
+
+      context = [context] if context.is_a? ::String
+
+      self.class.attributes.each_with_object(Array.new) do |(sub_attribute_name, sub_attribute), errors|
+        sub_context = self.class.generate_subcontext(context,sub_attribute_name)
+
+        value = self.send(sub_attribute_name)
+        if value.respond_to?(:validating) # really, it's a thing with sub-attributes
+          next if value.validating
+        end
+
+        errors.push *sub_attribute.validate(value, sub_context)
+      end
+    ensure
+      @validating = false
+    end
+
+
+    def attributes
+      @lazy_attributes.keys.each do |name|
+        self.send(name)
+      end
+      @attributes
+    end
+
+
+    def respond_to_missing?(name,*)
+      attribute_name = name.to_s
+      attribute_name.chomp!('=')
+
+      return true if self.class.attributes.key?(attribute_name.to_sym)
+
+      super
+    end
+
+
+    def method_missing(name, *args)
+      attribute_name = name.to_s
+      attribute_name.chomp!('=')
+
+      if self.class.attributes.has_key?(attribute_name.to_sym)
+        self.class.define_accessors(attribute_name)
+        return self.send(name, *args)
+      end
+
+      super
+    end
+
+
+    def dump(context: Attributor::DEFAULT_ROOT_CONTEXT, **opts)
+      return CIRCULAR_REFERENCE_MARKER if @dumping
+
+      @dumping = true
+
+      self.attributes.each_with_object({}) do |(name, value), result|
+        attribute = self.class.attributes[name]
+
+        result[name.to_sym] = attribute.dump(value, context: context + [name] )
+      end
+    ensure
+      @dumping = false
+    end
+
+  end
+end

data/lib/attributor/types/object.rb

@@ -0,0 +1,19 @@
+# Represents any Object
+
+require_relative '../exceptions'
+
+module Attributor
+
+  class Object
+    include Type
+
+    def self.native_type
+      return ::BasicObject
+    end
+
+    def self.example(context=nil, options:{})
+      'An Object'
+    end
+
+  end
+end

data/lib/attributor/types/string.rb

@@ -0,0 +1,25 @@
+module Attributor
+  class String
+    include Type
+
+    def self.native_type
+      return ::String
+    end
+
+
+    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      String(value)
+    rescue
+      super
+    end
+
+    def self.example(context=nil, options:{})
+      if options[:regexp]
+        return options[:regexp].gen
+      else
+        return /\w+/.gen
+      end
+    end
+  end
+  
+end