gorillib 0.4.1pre → 0.4.2pre

data/lib/gorillib/model/defaults.rb

@@ -9,19 +9,7 @@ module Gorillib
         attribute_set?(:default)
       end
     end
-
-    # This is called by `read_attribute` if an attribute is unset; you should
-    # not call this directly.  You might use this to provide defaults, or lazy
-    # access, or layered resolution.
-    #
-    # @param [String, Symbol, #to_s] field_name Name of the attribute to unset.
-    # @return [nil] Ze goggles! Zey do nussing!
-    def read_unset_attribute(field_name)
-      field = self.class.fields[field_name]
-      return unless field.has_default?
-      write_attribute(field.name, attribute_default(field))
-    end
-
+    
     # FieldDefaults allows defaults to be declared for your fields
     #
     # Defaults are declared by passing the :default option to the field
@@ -50,6 +38,60 @@ module Gorillib
     #   event.end_date.to_s #=> "2012-01-01"
     #
 
+    # This is called by `read_attribute` if an attribute is unset; you should
+    # not call this directly.  You might use this to provide defaults, or lazy
+    # access, or layered resolution.
+    # 
+    # Once a non-nil default value has been read, it is **fixed on the field**; this method
+    # will not be called again, and `attribute_set?(...)` will return `true`.
+    #
+    # @example values are fixed on read
+    #     class Defaultable
+    #       include Gorillib::Model
+    #       field :timestamp, Integer, default: ->{ Time.now }
+    #     end
+    #     dd = Defaultable.new
+    #     dd.attribute_set?(:timestamp) # => false
+    #     dd.timestamp                  # => '2012-01-02 12:34:56 CST'
+    #     dd.attribute_set?(:timestamp) # => true
+    #     # The block is *not* re-run -- the time is the same
+    #     dd.timestamp                  # => '2012-01-02 12:34:56 CST'
+    #
+    # @example If the default is a literal nil it is set as normal:
+    #
+    #     Defaultable.field :might_be_nil, String, default: nil
+    #     dd.attribute_set?(:might_be_nil) # => false
+    #     dd.might_be_nil                  # => nil
+    #     dd.attribute_set?(:might_be_nil) # => true
+    #
+    # If the default is generated from a block (or anything but a literal nil), no default is set:
+    #
+    #     Defaultable.field :might_be_nil,     String, default: ->{ puts 'ran!'; some_other_value ? some_other_value.reverse : nil }
+    #     Defaultable.field :some_other_value, String
+    #     dd = Defaultable.new
+    #     dd.attribute_set?(:might_be_nil) # => false
+    #     dd.might_be_nil                  # => nil
+    #     'ran!'  # block was run
+    #     dd.might_be_nil                  # => nil
+    #     'ran!'  # block was run again
+    #     dd.some_other_val = 'hello'
+    #     dd.might_be_nil                  # => 'olleh'
+    #     'ran!'  # block was run again, and set a value this time
+    #     dd.some_other_val = 'goodbye'
+    #     dd.might_be_nil                  # => 'olleh'
+    #     # block was not run again
+    #
+    # @param [String, Symbol, #to_s] field_name Name of the attribute to unset.
+    # @return [Object] The new value
+    def read_unset_attribute(field_name)
+      field = self.class.fields[field_name] or return nil
+      return unless field.has_default?
+      val = attribute_default(field) 
+      return nil if val.nil? && (not field.default.nil?) # don't write nil unless intent is clearly to have default nil 
+      write_attribute(field.name, val)
+    end
+
+
   protected
 
     # the actual default value to assign to the attribute
@@ -57,8 +99,10 @@ module Gorillib
       return unless field.has_default?
       val = field.default
       case
-      when (val.is_a?(Proc) || val.is_a?(UnboundMethod)) && (val.arity == 0)
+      when val.is_a?(Proc) && (val.arity == 0)
         self.instance_exec(&val)
+      when val.is_a?(UnboundMethod) && (val.arity == 0)
+        val.bind(self).call
       when val.respond_to?(:call)
         val.call(self, field.name)
       else

data/lib/gorillib/model/errors.rb

@@ -10,5 +10,15 @@ module Gorillib
       include Gorillib::Model::Error
     end
 
+    class ConflictingPositionError < ::ArgumentError
+      include Gorillib::Model::Error
+    end
+
+    # Exception raised if deserialized attributes don't have the right shape:
+    # for example, a CSV line with too many/too few fields
+    class RawDataMismatchError < ::StandardError
+      include Gorillib::Model::Error
+    end
+
   end
 end

data/lib/gorillib/model/factories.rb

@@ -1,367 +1 @@
-require 'pathname'
-require 'gorillib/type/extended'
-
-def Gorillib::Factory(*args)
-  ::Gorillib::Factory.receive(*args)
-end
-
-module Gorillib
-
-  module Factory
-    class FactoryMismatchError < ArgumentError ; end
-
-    def self.receive(type)
-      case
-      when factories.include?(type)               then return factories[type]
-      when type.respond_to?(:receive)             then return type
-      when type.is_a?(Proc) || type.is_a?(Method) then return Gorillib::Factory::ApplyProcFactory.new(type)
-      when type.is_a?(String)                     then
-        return( factories[type] = Gorillib::Inflector.constantize(Gorillib::Inflector.camelize(type.gsub(/\./, '/'))) )
-      else raise ArgumentError, "Don't know which factory makes a #{type}"
-      end
-    end
-
-    # Manufactures objects from their raw attributes hash
-    #
-    # A hash with a value for `:_type` is dispatched to the corresponding factory
-    # Everything else is returned directly
-    def self.make(obj)
-      if obj.respond_to?(:has_key?) && (obj.has_key?(:_type) || obj.has_key?('_type'))
-        factory = Gorillib::Factory(attrs[:_type])
-        factory.receive(obj)
-      else
-        obj
-      end
-    end
-
-    private
-    def self.factories
-      @factories ||= Hash.new
-    end
-    public
-
-    def self.register_factory(factory, typenames)
-      typenames.each{|typename| factories[typename] = factory }
-    end
-
-    class BaseFactory
-      # [Class] The type of objects produced by this factory
-      class_attribute :product
-
-      def initialize(options={})
-        @product       = options.delete(:product){ self.class.product }
-        if options[:blankish]
-          define_singleton_method(:blankish, options.delete(:blankish))
-        end
-        redefine(:convert, options.delete(:convert)) if options.has_key?(:convert)
-        warn "Unknown options #{options.keys}" unless options.empty?
-      end
-
-      def self.typename
-        @typename ||= Gorillib::Inflector.underscore(product.name).to_sym
-      end
-      def typename ; self.class.typename ; end
-
-      # A `native` object does not need any transformation; it is accepted directly.
-      # By default, an object is native if it `is_a?(product)`
-      #
-      # @param   [Object]      obj the object to convert and receive
-      # @return [true, false] true if the item does not need conversion
-      def native?(obj)
-        obj.is_a?(@product)
-      end
-      def self.native?(obj) self.new.native?(obj) ; end
-
-      # A `blankish` object should be converted to `nil`, not a value
-      #
-      # @param   [Object]      obj the object to convert and receive
-      # @return [true, false] true if the item is equivalent to a nil value
-      def blankish?(obj)
-        obj.nil? || (obj == "")
-      end
-      def self.blankish?(obj)
-        obj.nil? || (obj == "")
-      end
-
-    protected
-
-      def redefine(meth, *args, &block)
-        if args.present?
-          val = args.first
-          case
-          when block_given? then raise ArgumentError, "Pass a block or a value, not both"
-          when val.is_a?(Proc) || val.is_a?(Method) then block = val
-          else block = ->(*){ val.try_dup }
-          end
-        end
-        define_singleton_method(meth, &block)
-        self
-      end
-
-      # Raises a FactoryMismatchError.
-      def mismatched!(obj, message=nil, *args)
-        message ||= "item cannot be converted to #{product}"
-        message <<  (" got #{obj.inspect}" rescue ' (and is uninspectable)')
-        raise FactoryMismatchError, message, *args
-      end
-
-      def self.register_factory!(*typenames)
-        typenames = [typename, product] if typenames.empty?
-        Gorillib::Factory.register_factory(self.new, typenames)
-      end
-    end
-
-    class ConvertingFactory < BaseFactory
-      def receive(obj)
-        return nil  if blankish?(obj)
-        return obj  if native?(obj)
-        convert(obj)
-      rescue NoMethodError, TypeError, RangeError => err
-        mismatched!(obj, err.message, err.backtrace)
-      end
-    protected
-      # Convert a receivable object to the factory's product type. This method
-      # should convert an object to `native?` form or die trying; any
-      # polymorphism (such as converting an empty string to nil) happens in
-      # other methods called by `receive`.
-      #
-      # @param [Object] obj the object to convert.
-      def convert(obj)
-        obj.dup
-      end
-    end
-
-    #
-    # A NonConvertingFactory accepts objects that are *already* native, and
-    # throws a mismatch error for anything else.
-    #
-    # @example
-    #   ff = Gorillib::Factory::NonConvertingFactory.new(:product => String, :blankish => ->(obj){ obj.nil? })
-    #   ff.receive(nil)    #=> nil
-    #   ff.receive("bob")  #=> "bob"
-    #   ff.receive(:bob)   #=> Gorillib::Factory::FactoryMismatchError: must be an instance of String, got 3
-    #
-    class NonConvertingFactory < BaseFactory
-      def blankish?(obj) obj.nil? ; end
-      def receive(obj)
-        return nil  if blankish?(obj)
-        return obj  if native?(obj)
-        mismatched!(obj, "must be an instance of #{product},")
-      rescue NoMethodError => err
-        mismatched!(obj, err.message, err.backtrace)
-      end
-    end
-
-    class ::Whatever < BaseFactory
-      def initialize(options={})
-        options.slice!(:convert, :blankish)
-        super(options)
-      end
-      def native?(obj)   true  ; end
-      def blankish?(obj) false ; end
-      def receive(obj)   obj   ; end
-      def self.receive(obj)
-        obj
-      end
-      Gorillib::Factory.register_factory(self, [self, :identical, :whatever])
-    end
-    IdenticalFactory = ::Whatever unless defined?(IdenticalFactory)
-
-    # __________________________________________________________________________
-    #
-    #  Concrete Factories
-    # __________________________________________________________________________
-
-    class StringFactory < ConvertingFactory
-      self.product = String
-      def blankish?(obj)    obj.nil? ; end
-      def native?(obj)      obj.respond_to?(:to_str)  end
-      def convert(obj)      obj.to_s                  end
-      register_factory!
-    end
-
-    class GuidFactory      < StringFactory ; self.product = ::Guid      ; register_factory! ; end
-    class HostnameFactory  < StringFactory ; self.product = ::Hostname  ; register_factory! ; end
-    class IpAddressFactory < StringFactory ; self.product = ::IpAddress ; register_factory! ; end
-
-    class BinaryFactory < StringFactory
-      def convert(obj)
-        super.force_encoding("BINARY")
-      end
-      register_factory!(:binary)
-    end
-
-    class PathnameFactory  < ConvertingFactory
-      self.product = ::Pathname
-      def convert(obj)      Pathname.new(obj)         end
-      register_factory!
-    end
-
-    class SymbolFactory < ConvertingFactory
-      self.product = Symbol
-      def convert(obj)      obj.to_sym                end
-      register_factory!
-    end
-
-    class RegexpFactory < ConvertingFactory
-      self.product = Regexp
-      def convert(obj)      Regexp.new(obj)           end
-      register_factory!
-    end
-
-    class IntegerFactory < ConvertingFactory
-      self.product = Integer
-      def convert(obj)      obj.to_i                  end
-      register_factory!(:int, :integer, Integer)
-    end
-    class BignumFactory < IntegerFactory
-      self.product = Bignum
-      register_factory!
-    end
-    class FloatFactory < ConvertingFactory
-      self.product = Float
-      def convert(obj)      obj.to_f                  end
-      register_factory!
-    end
-    class ComplexFactory < ConvertingFactory
-      self.product = Complex
-      def convert(obj)      obj.to_c                  end
-      register_factory!
-    end
-    class RationalFactory < ConvertingFactory
-      self.product = Rational
-      def convert(obj)      obj.to_r                  end
-      register_factory!
-    end
-
-    class TimeFactory < ConvertingFactory
-      self.product = Time
-      def convert(obj)
-        case obj
-        when String
-          Time.parse(obj).utc
-        when Numeric
-          Time.at(obj).utc
-        end
-      rescue ArgumentError => err
-        warn "Cannot parse time #{obj}: #{err}"
-        return nil
-      end
-      register_factory!
-    end
-
-    # __________________________________________________________________________
-
-    class ClassFactory  < NonConvertingFactory ; self.product = Class      ; register_factory! ; end
-    class ModuleFactory < NonConvertingFactory ; self.product = Module     ; register_factory! ; end
-    class TrueFactory   < NonConvertingFactory ; self.product = TrueClass  ; register_factory!(:true, TrueClass) ; end
-    class FalseFactory  < NonConvertingFactory ; self.product = FalseClass ; register_factory!(:false, FalseClass) ; end
-
-    class ExceptionFactory < NonConvertingFactory ; self.product = Exception ; register_factory!(:exception, Exception) ; end
-
-    class NilFactory    < NonConvertingFactory
-      self.product       = NilClass
-      def blankish?(obj) false ; end
-      register_factory!(:nil, NilClass)
-    end
-
-    class BooleanFactory < ConvertingFactory
-      self.product       = [TrueClass, FalseClass]
-      def blankish?(obj)    obj.nil? ; end
-      def native?(obj)     obj.equal?(true) || obj.equal?(false) ; end
-      def convert(obj)     (obj.to_s == "false") ? false : true ; end
-      register_factory!(:boolean)
-      def self.typename() :boolean ; end
-    end
-
-    #
-    #
-    #
-
-    class EnumerableFactory < ConvertingFactory
-      # [#receive] factory for converting items
-      attr_reader :items_factory
-
-      def initialize(options={})
-        @items_factory = Gorillib::Factory.receive( options.delete(:items){ Gorillib::Factory(:identical) } )
-        redefine(:empty_product, options.delete(:empty_product)) if options.has_key?(:empty_product)
-        super(options)
-      end
-
-      def blankish?(obj)    obj.nil? ; end
-      def native?(obj)      false    ; end
-
-      def empty_product
-        @product.new
-      end
-
-      def convert(obj)
-        clxn = empty_product
-        obj.each do |val|
-          clxn << items_factory.receive(val)
-        end
-        clxn
-      end
-    end
-
-    class ArrayFactory < EnumerableFactory
-      self.product = Array
-      register_factory!
-    end
-
-    class SetFactory < EnumerableFactory
-      self.product = Set
-      register_factory!
-    end
-
-    class HashFactory < EnumerableFactory
-      # [#receive] factory for converting keys
-      attr_reader :keys_factory
-      self.product = Hash
-
-      def initialize(options={})
-        @keys_factory = Gorillib::Factory( options.delete(:keys){ Gorillib::Factory(:identical) } )
-        super(options)
-      end
-
-      def convert(obj)
-        hsh = empty_product
-        obj.each_pair do |key, val|
-          hsh[keys_factory.receive(key)] = items_factory.receive(val)
-        end
-        hsh
-      end
-      register_factory!
-    end
-
-    class RangeFactory < NonConvertingFactory
-      self.product       = Range
-      def blankish?(obj)    obj.nil? || obj == [] ; end
-      register_factory!
-    end
-
-    # __________________________________________________________________________
-
-    class ApplyProcFactory < ConvertingFactory
-      attr_reader :callable
-
-      def initialize(callable=nil, options={}, &block)
-        if block_given?
-          raise ArgumentError, "Pass a block or a value, not both" unless callable.nil?
-          callable = block
-        end
-        @callable = callable
-        super(options)
-      end
-      def blankish?(obj)    obj.nil? ; end
-      def native?(val)      false    ; end
-      def convert(obj)
-        callable.call(obj)
-      end
-      register_factory!(:proc)
-    end
-
-
-  end
-
-end
+require_relative '../factories'