gorillib 0.4.1pre → 0.4.2pre

data/lib/gorillib/model/field.rb

@@ -15,7 +15,7 @@ module Gorillib
       attr_reader :model
 
       # [Hash] all options passed to the field not recognized by one of its own current fields
-      attr_reader :extra_attributes
+      attr_reader :_extra_attributes
 
       # Note: `Gorillib::Model::Field` is assembled in two pieces, so that it
       # can behave as a model itself. Defining `name` here, along with some
@@ -28,7 +28,6 @@ module Gorillib
       class_attribute :visibilities, :instance_writer => false
       self.visibilities = { :reader => :public, :writer => :public, :receiver => :public, :tester => false }
 
-
       # @param [#to_sym]                name    Field name
       # @param [#receive]               type    Factory for field values. To accept any object as-is, specify `Object` as the type.
       # @param [Gorillib::Model]       model   Field's owner
@@ -38,11 +37,14 @@ module Gorillib
       # @option options [true, false, :public, :protected, :private] :writer   Visibility for the writer (`#foo=`) method; `false` means don't create one.
       # @option options [true, false, :public, :protected, :private] :receiver Visibility for the receiver (`#receive_foo`) method; `false` means don't create one.
       #
-      def initialize(name, type, model, options={})
+      def initialize(model, name, type, options={})
         Validate.identifier!(name)
+        type_opts         = options.extract!(:blankish, :empty_product, :items, :keys, :of)
+        type_opts[:items] = type_opts.delete(:of) if type_opts.has_key?(:of)
+        #
         @model            = model
         @name             = name.to_sym
-        @type             = self.factory_for(type)
+        @type             = Gorillib::Factory.factory_for(type, type_opts)
         default_visabilities = visibilities
         @visibilities     = default_visabilities.merge( options.extract!(*default_visabilities.keys) )
         @doc              = options.delete(:name){ "#{name} field" }
@@ -56,29 +58,28 @@ module Gorillib
         name.to_s
       end
 
-      def factory_for(type)
-        Gorillib::Factory(type)
-      end
-
       # @return [String] Human-readable presentation of the field definition
       def inspect
-        args = [name.inspect, type.to_s]
-        "field(#{args.join(", ")})"
+        args = [name.inspect, type.to_s, attributes.reject{|k,v| k =~ /^(name|type)$/}.inspect]
+        "field(#{args.join(",")})"
+      end
+      def inspect_compact
+        "field(#{name})"
       end
 
       def to_hash
-        attributes.merge!(@visibility).merge!(@extra_attributes)
+        attributes.merge!(@visibility).merge!(@_extra_attributes)
       end
 
       def ==(val)
-        super && (val.extra_attributes == self.extra_attributes) && (val.model == self.model)
+        super && (val._extra_attributes == self._extra_attributes) && (val.model == self.model)
       end
 
       def self.receive(hsh)
         name  = hsh.fetch(:name)
         type  = hsh.fetch(:type)
         model = hsh.fetch(:model)
-        new(name, type, model, hsh)
+        new(model, name, type, hsh)
       end
 
       #
@@ -110,22 +111,43 @@ module Gorillib
       # Now we can construct the actual fields.
       #
 
+      field :position, Integer, :tester => true,       :doc => "Indicates this is a positional initialization arg -- you can pass it as a plain value in the given slot to #initialize"
+
       # Name of this field. Must start with `[A-Za-z_]` and subsequently contain only `[A-Za-z0-9_]` (required)
       # @macro [attach] field
       #   @attribute $1
       #   @return [$2] the $1 field $*
-      field :name, String, :writer => false, :doc => "The field name. Must start with `[A-Za-z_]` and subsequently contain only `[A-Za-z0-9_]` (required)"
+      field :name, String, position: 0, writer: false, doc: "The field name. Must start with `[A-Za-z_]` and subsequently contain only `[A-Za-z0-9_]` (required)"
 
-      # Factory for the field's values
-      field :type, Class
+      field :type, Class,  position: 1,                doc: "Factory to generate field's values"
 
-      # Field's description
-      field :doc, String
+      field :doc,  String,                             doc: "Field's description"
 
       # remove the attr_reader method (needed for scaffolding), leaving the meta_module method to remain
       remove_possible_method(:name)
 
     end
+
+
+    class SimpleCollectionField < Gorillib::Model::Field
+      field :item_type,        Class, default: Whatever, doc: "Factory for collection items"
+      # field :collection_attrs, Hash,  default: Hash.new, doc: "Extra attributes to pass to the collection on creation -- eg. key_method"
+
+      def initialize(model, name, type, options={})
+        super
+        collection_type = self.type
+        item_type       = self.item_type
+        key_method      = options[:key_method] if options[:key_method]
+        raise "Please supply an item type for #{self.inspect} -- eg 'collection #{name.inspect}, of: FooClass'" unless item_type
+        self.default ||= ->{ collection_type.new(item_type: item_type, belongs_to: self, key_method: key_method) }
+      end
+
+      def inscribe_methods(model)
+        super
+        model.__send__(:define_collection_receiver, self)
+      end
+    end
+
   end
 end
 

data/lib/gorillib/model/fixup.rb

@@ -0,0 +1,16 @@
+::Gorillib::Model::Field.class_eval do
+  field :fixup, Symbol, doc: 'key to remap before receive', tester: true
+end
+
+module ::Gorillib::StringFixup
+  extend Gorillib::Concern
+  
+  # intercept to replace fixup-able hash keys with the proper field name in the receive hash
+  def receive!(hsh={})
+    self.class.fields.each do |field_name, field|
+      next unless field.fixup?
+      hsh[field_name] = hsh.delete(field.fixup) if hsh.has_key?(field.fixup)
+    end
+    super(hsh)
+  end
+end

data/lib/gorillib/model/positional_fields.rb

@@ -0,0 +1,35 @@
+module Gorillib
+  module Model
+
+    #
+    # give each field the next position in order
+    #
+    # @example
+    #   class Foo
+    #     include Gorillib::Model
+    #     field :bob,    String               # not positional
+    #     field :zoe,    String, position: 0  # positional 0 (explicit)
+    #   end
+    #   class Subby < Foo
+    #     include Gorillib::Model::PositionalFields
+    #     field :wun, String                  # positional 1
+    #   end
+    #   Foo.field    :nope, String            # not positional
+    #   Subby.field  :toofer, String          # positional 2
+    #
+    # @note: make sure you're keeping positionals straight in super classes, or
+    # in anything added after this.
+    #
+    module PositionalFields
+      extend Gorillib::Concern
+
+      module ClassMethods
+        def field(*args)
+          options = args.extract_options!
+          super(*args, {position: positionals.count}.merge(options))
+        end
+      end
+
+    end
+  end
+end

data/lib/gorillib/model/schema_magic.rb

@@ -0,0 +1,162 @@
+module Gorillib
+  module Model
+
+    module ClassMethods
+
+      # Defines a new field
+      #
+      # For each field that is defined, a getter and setter will be added as
+      # an instance method to the model. An Field instance will be added to
+      # result of the fields class method.
+      #
+      # @example
+      #   field :height, Integer
+      #
+      # @param [Symbol] field_name             The field name. Must start with `[A-Za-z_]` and subsequently contain only `[A-Za-z0-9_]`
+      # @param [Class]  type                   The field's type (required)
+      # @option options [String] doc           Documentation string for the field (optional)
+      # @option options [Proc, Object] default Default value, or proc that instance can evaluate to find default value
+      #
+      # @return Gorillib::Model::Field
+      def field(field_name, type, options={})
+        options = options.symbolize_keys
+        field_type = options.delete(:field_type){ ::Gorillib::Model::Field }
+        fld = field_type.new(self, field_name, type, options)
+        @_own_fields[fld.name] = fld
+        _reset_descendant_fields
+        fld.send(:inscribe_methods, self)
+        fld
+      end
+
+      def collection(field_name, collection_type, options={})
+        options[:item_type] = options[:of] if options.has_key?(:of)
+        field(field_name, collection_type, {
+            field_type: ::Gorillib::Model::SimpleCollectionField}.merge(options))
+      end
+
+      # @return [{Symbol => Gorillib::Model::Field}]
+      def fields
+        return @_fields if defined?(@_fields)
+        @_fields = ancestors.reverse.inject({}){|acc, ancestor| acc.merge!(ancestor.try(:_own_fields) || {}) }
+      end
+
+      # @return [true, false] true if the field is defined on this class
+      def has_field?(field_name)
+        fields.has_key?(field_name)
+      end
+
+      # @return [Array<Symbol>] The attribute names
+      def field_names
+        @_field_names ||= fields.keys
+      end
+
+      def positionals
+        @_positionals ||= assemble_positionals
+      end
+
+      def assemble_positionals
+        positionals = fields.values.keep_if{|fld| fld.position? }.sort_by!{|fld| fld.position }
+        return [] if positionals.empty?
+        if (positionals.map(&:position) != (0..positionals.length-1).to_a) then raise ConflictingPositionError, "field positions #{positionals.map(&:position).join(",")} for #{positionals.map(&:name).join(",")} aren't in strict minimal order"  ; end
+        positionals.map!(&:name)
+      end
+
+      # turn model constructor args (`*positional_args, {attrs}`) into a combined
+      # attrs hash. positional_args are mapped to the set of attribute names in
+      # order -- by default, the class' field names.
+      #
+      # Notes:
+      #
+      # * Positional args always clobber elements of the attribute hash.
+      # * Nil positional args are treated as present-and-nil (this might change).
+      # * Raises an error if positional args
+      #
+      # @param [Array[Symbol]] args list of attributes, in order, to map.
+      #
+      # @return [Hash] a combined, reconciled hash of attributes to set
+      def attrs_hash_from_args(args)
+        attrs = args.extract_options!
+        if args.present?
+          ArgumentError.check_arity!(args, 0..positionals.length){ "extracting args #{args} for #{self}" }
+          positionals_to_map = positionals[0..(args.length-1)]
+          attrs = attrs.merge(Hash[positionals_to_map.zip(args)])
+        end
+        attrs
+      end
+
+    protected
+
+      attr_reader :_own_fields
+
+      # Ensure that classes inherit all their parents' fields, even if fields
+      # are added after the child class is defined.
+      def _reset_descendant_fields
+        ObjectSpace.each_object(::Class) do |klass|
+          klass.__send__(:remove_instance_variable, '@_fields')      if (klass <= self) && klass.instance_variable_defined?('@_fields')
+          klass.__send__(:remove_instance_variable, '@_field_names') if (klass <= self) && klass.instance_variable_defined?('@_field_names')
+          klass.__send__(:remove_instance_variable, '@_positionals') if (klass <= self) && klass.instance_variable_defined?('@_positionals')
+        end
+      end
+
+      # define the reader method `#foo` for a field named `:foo`
+      def define_attribute_reader(field_name, field_type, visibility)
+        define_meta_module_method(field_name, visibility) do
+          begin
+            read_attribute(field_name)
+          rescue StandardError => err ; err.polish("#{self.class}.#{field_name}") rescue nil ; raise ; end
+        end
+      end
+
+      # define the writer method `#foo=` for a field named `:foo`
+      def define_attribute_writer(field_name, field_type, visibility)
+        define_meta_module_method("#{field_name}=", visibility) do |val|
+          write_attribute(field_name, val)
+        end
+      end
+
+      # define the present method `#foo?` for a field named `:foo`
+      def define_attribute_tester(field_name, field_type, visibility)
+        field = fields[field_name]
+        define_meta_module_method("#{field_name}?", visibility) do
+          attribute_set?(field_name) || field.has_default?
+        end
+      end
+
+      def define_attribute_receiver(field_name, field_type, visibility)
+        # @param  [Object] val the raw value to type-convert and adopt
+        # @return [Object] the attribute's new value
+        define_meta_module_method("receive_#{field_name}", visibility) do |val|
+          begin
+            val = field_type.receive(val)
+            write_attribute(field_name, val)
+          rescue StandardError => err ; err.polish("#{self.class}.#{field_name} type #{type} on #{val}") rescue nil ; raise ; end
+        end
+      end
+
+      #
+      # Collection receiver --
+      #
+      def define_collection_receiver(field)
+        collection_field_name = field.name; collection_type = field.type
+        # @param  [Array[Object],Hash[Object]] the collection to merge
+        # @return [Gorillib::Collection] the updated collection
+        define_meta_module_method("receive_#{collection_field_name}", true) do |coll, &block|
+          begin
+            if collection_type.native?(coll)
+              write_attribute(collection_field_name, coll)
+            else
+              read_attribute(collection_field_name).receive!(coll, &block)
+            end
+          rescue StandardError => err ; err.polish("#{self.class} #{collection_field_name} collection on #{args}'") rescue nil ; raise ; end
+        end
+      end
+
+      def inherited(base)
+        base.instance_eval do
+          @_own_fields ||= {}
+        end
+        super
+      end
+    end
+  end
+end

data/lib/gorillib/model/serialization.rb

@@ -1,4 +1,3 @@
-
 class Array
   def to_tsv
     join("\t")
@@ -25,7 +24,7 @@ module Gorillib
 
     module ClassMethods
       def from_tuple(*vals)
-        receive Hash[field_names[0..vals.length].zip(vals)]
+        receive Hash[field_names[0..vals.length-1].zip(vals)]
       end
     end
 

data/lib/gorillib/model/serialization/csv.rb

@@ -0,0 +1,59 @@
+require 'csv'
+require 'gorillib/pathname'
+
+module Gorillib
+  module Model
+
+    module LoadFromCsv
+      extend Gorillib::Concern
+      included do |base|
+        # Options that will be passed to CSV. Be careful to modify with assignment (`+=`) and not in-place (`<<`)
+        base.class_attribute :csv_options
+        base.csv_options = Hash.new
+      end
+
+      module ClassMethods
+
+        # Iterate a block over each line of a CSV file
+        #
+        # @raise [Gorillib::Model::RawDataMismatchError] if a line has too many or too few fields
+        # @yield an object instantiated from each line in the file.
+        def each_in_csv(filename, options={})
+          filename = Pathname.path_to(filename)
+          options = csv_options.merge(options)
+          pop_headers = options.delete(:pop_headers)
+          num_fields  = options.delete(:num_fields){ (fields.length .. fields.length) }
+          raise ArgumentError, "The :headers option to CSV changes its internal behavior; use 'pop_headers: true' to ignore the first line" if options[:headers]
+          CSV.open(filename, options) do |csv_file|
+            csv_file.shift if pop_headers
+            csv_file.each do |tuple|
+              next if tuple.empty?
+              unless num_fields.include?(tuple.length) then raise Gorillib::Model::RawDataMismatchError, "yark, spurious fields: #{tuple.inspect}" ; end
+              yield from_tuple(*tuple)
+            end
+            nil
+          end
+        end
+
+        # With a block, calls block on each object in turn (and returns nil)
+        #
+        # With no block, accumulates all the instances into the array it
+        # returns. As opposed to the with-a-block case, the memory footprint of
+        # this increases as the filesize does, so use caution with large files.
+        #
+        # @return with a block, returns nil; with no block, an array of this class' instances
+        def load_csv(*args)
+          if block_given?
+            each_in_csv(*args, &Proc.new)
+          else
+            objs = []
+            each_in_csv(*args){|obj| objs << obj }
+            objs
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/lib/gorillib/pathname.rb

@@ -52,9 +52,11 @@ module Gorillib
     #   any mixture of strings (literal sub-paths) and symbols (interpreted as references)
     # @return [Pathname] A single expanded Pathname
     #
-    def path_to(*pathsegs)
-      relative_path_to(*pathsegs).expand_path
+    def of(*pathsegs)
+      relpath_to(*pathsegs).expand_path
     end
+    alias_method :path_to, :of
+
 
     # Expand a path with late-evaluated segments
     # @see `.path_to`
@@ -62,16 +64,12 @@ module Gorillib
     # Calls cleanpath (removing `//` double slashes and useless `..`s), but does
     # not reference the filesystem or make paths absolute
     #
-    def relative_path_to(*pathsegs)
+    def relpath_to(*pathsegs)
       ArgumentError.arity_at_least!(pathsegs, 1)
       pathsegs = pathsegs.map{|ps| expand_pathseg(ps) }.flatten
       self.new(File.join(*pathsegs)).cleanpath(true)
     end
-    def relpath_to(*args) relative_path_to(*args) ; end
-
-    # def make_pathname(*args)
-    #   Pathname.new(*args)
-    # end
+    alias_method :relative_path_to, :relpath_to
 
   protected
     # Recursively expand a path handle
@@ -88,6 +86,19 @@ class Pathname
   extend Gorillib::Pathref
   class << self ; alias_method :new_pathname, :new ; end
 
+  def self.receive(obj)
+    return obj if obj.nil?
+    obj.is_a?(self) ? obj : new(obj)
+  end
+
+  # @return the basename without extension (using self.extname as the extension)
+  def corename
+    basename(self.extname)
+  end
+
+  # @return [String] compact string rendering
+  def inspect_compact() to_path.dump ; end
+
   # FIXME: find out if this is dangerous
   alias_method :to_str, :to_path
 end