gorillib 0.1.11 → 0.4.0pre

data/lib/gorillib/builder.rb

@@ -0,0 +1,260 @@
+require 'gorillib/string/simple_inflector'
+require 'gorillib/model'
+
+module Gorillib
+  module Builder
+    extend  Gorillib::Concern
+    include Gorillib::Model
+
+    def initialize(attrs={}, &block)
+      receive!(attrs, &block)
+    end
+
+    def receive!(*args, &block)
+      super(*args)
+      if block_given?
+        (block.arity == 1) ? block.call(self) : self.instance_eval(&block)
+      end
+      self
+    end
+
+    def getset(field, *args, &block)
+      ArgumentError.check_arity!(args, 0..1)
+      if args.empty?
+        read_attribute(field.name)
+      else
+        write_attribute(field.name, args.first)
+      end
+    end
+
+    def getset_member(field, *args, &block)
+      ArgumentError.check_arity!(args, 0..1)
+      attrs = args.first
+      if attrs.is_a?(field.type)
+        # actual object: assign it into field
+        val = attrs
+        write_attribute(field.name, val)
+      else
+        val = read_attribute(field.name)
+        if val.present?
+          # existing item: update it with args and block
+          val.receive!(*args, &block) if args.present?
+        elsif attrs.blank?
+          # missing item (read): return nil
+          return nil
+        else
+          # missing item (write): construct item and add to collection
+          options = args.extract_options!.merge(:owner => self)
+          val = field.type.receive(*args, options, &block)
+          write_attribute(field.name, val)
+        end
+      end
+      val
+    end
+
+    def getset_collection_item(field, item_key, attrs={}, &block)
+      plural_name = field.plural_name
+      if attrs.is_a?(field.item_type)
+        # actual object: assign it into collection
+        val = attrs
+        set_collection_item(plural_name, item_key, val)
+      elsif has_collection_item?(plural_name, item_key)
+        # existing item: retrieve it, updating as directed
+        val = get_collection_item(plural_name, item_key)
+        val.receive!(attrs, &block)
+      else
+        # missing item: autovivify item and add to collection
+        val = field.item_type.receive({ key_method => item_key, :owner => self }.merge(attrs), &block)
+        set_collection_item(plural_name, item_key, val)
+      end
+      val
+    end
+
+    def get_collection_item(plural_name, item_key)
+      collection_of(plural_name)[item_key]
+    end
+
+    def set_collection_item(plural_name, item_key, item)
+      collection_of(plural_name)[item_key] = item
+    end
+
+    def has_collection_item?(plural_name, item_key)
+      collection_of(plural_name).include?(item_key)
+    end
+
+    def key_method
+      :name
+    end
+
+    def to_key
+      self.read_attribute(key_method)
+    end
+
+    def inspect_helper(detailed, attrs)
+      attrs.delete(:owner)
+      # detailed ? str : ([str[0..-2], " #{to_key}>"].join)
+      str = super(detailed, attrs)
+    end
+
+    def collection_of(plural_name)
+      self.read_attribute(plural_name)
+    end
+
+    module ClassMethods
+      include Gorillib::Model::ClassMethods
+
+      def field(field_name, type, options={})
+        super(field_name, type, {:field_type => ::Gorillib::Builder::GetsetField}.merge(options))
+      end
+      def member(field_name, type, options={})
+        field(field_name, type, {:field_type => ::Gorillib::Builder::MemberField}.merge(options))
+      end
+      def collection(field_name, item_type, options={})
+        field(field_name, Gorillib::Collection, {
+            :item_type => item_type,
+            :field_type => ::Gorillib::Builder::CollectionField}.merge(options))
+      end
+      def simple_field(field_name, type, options={})
+        field(field_name, type, {:field_type => ::Gorillib::Model::Field}.merge(options))
+      end
+
+    protected
+
+      def define_attribute_getset(field)
+        field_name = field.name; type = field.type
+        define_meta_module_method(field_name, field.visibility(:reader)) do |*args, &block|
+          begin
+            getset(field, *args, &block)
+          rescue StandardError => err ; err.polish("#{self.class}.#{field_name} type #{type} on #{args}'") rescue nil ; raise ; end
+        end
+      end
+
+      def define_member_getset(field)
+        field_name = field.name; type = field.type
+        define_meta_module_method(field_name, field.visibility(:reader)) do |*args, &block|
+          begin
+            getset_member(field, *args, &block)
+          rescue StandardError => err ; err.polish("#{self.class}.#{field_name} type #{type} on #{args}'") rescue nil ; raise ; end
+        end
+      end
+
+      def define_collection_getset(field)
+        field_name = field.name; item_type = field.item_type
+        define_meta_module_method(field.singular_name, field.visibility(:collection_getset)) do |*args, &block|
+          begin
+            getset_collection_item(field, *args, &block)
+          rescue StandardError => err ; err.polish("#{self.class}.#{field_name} c[#{item_type}] on #{args}'") rescue nil ; raise ; end
+        end
+      end
+
+      def define_collection_receiver(field)
+        plural_name = field.name; item_type = field.item_type; field_type = field.type
+        define_meta_module_method("receive_#{plural_name}", true) do |coll, &block|
+          begin
+            if coll.is_a?(field_type)
+              write_attribute(plural_name, coll)
+            else
+              read_attribute(plural_name).receive!(coll, &block)
+            end
+            self
+          rescue StandardError => err ; err.polish("#{self.class} #{plural_name} c[#{item_type}] on #{args}'") rescue nil ; raise ; end
+        end
+      end
+
+      def define_collection_tester(field)
+        plural_name = field.plural_name
+        define_meta_module_method("has_#{field.singular_name}?", field.visibility(:collection_tester)) do |item_key|
+          begin
+            collection_of(plural_name).include?(item_key)
+          rescue StandardError => err ; err.polish("#{self.class}.#{plural_name} having #{item_key}?'") rescue nil ; raise ; end
+        end
+      end
+
+    end
+  end
+
+  module FancyBuilder
+    extend  Gorillib::Concern
+    include Gorillib::Builder
+
+    included do |base|
+      base.field :name,  Symbol
+    end
+
+    module ClassMethods
+      include Gorillib::Builder::ClassMethods
+
+      def belongs_to(field_name, type, options={})
+        field = field(field_name, type, {:field_type => ::Gorillib::Builder::MemberField }.merge(options))
+        define_meta_module_method "#{field.name}_name" do
+          val = getset_member(field) or return nil
+          val.name
+        end
+        field
+      end
+
+      def option(field_name, options={})
+        type = options.delete(:type){ Whatever }
+        field(field_name, type, {:field_type => ::Gorillib::Builder::GetsetField }.merge(options))
+      end
+
+      def collects(type, clxn_name)
+        type_handle = type.handle
+        define_meta_module_method type_handle do |item_name, attrs={}, options={}, &block|
+          send(clxn_name, item_name, attrs, options.merge(:factory => type), &block)
+        end
+      end
+    end
+  end
+
+  module Builder
+
+    class GetsetField < Gorillib::Model::Field
+      self.visibilities = visibilities.merge(:writer => false, :tester => false, :getset => true)
+      def inscribe_methods(model)
+        model.__send__(:define_attribute_getset,   self)
+        model.__send__(:define_attribute_writer,   self.name, self.type, visibility(:writer))
+        model.__send__(:define_attribute_tester,   self.name, self.type, visibility(:tester))
+        model.__send__(:define_attribute_receiver, self.name, self.type, visibility(:receiver))
+      end
+    end
+
+    class MemberField < Gorillib::Model::Field
+      self.visibilities = visibilities.merge(:writer => false, :tester => true)
+      def inscribe_methods(model)
+        model.__send__(:define_member_getset,      self)
+        model.__send__(:define_attribute_writer,   self.name, self.type, visibility(:writer))
+        model.__send__(:define_attribute_tester,   self.name, self.type, visibility(:tester))
+        model.__send__(:define_attribute_receiver, self.name, self.type, visibility(:receiver))
+      end
+    end
+
+    class CollectionField < Gorillib::Model::Field
+      field :singular_name, Symbol, :default => ->{ Gorillib::Inflector.singularize(name.to_s).to_sym }
+      field :item_type, Class, :default => Whatever
+
+      self.visibilities = visibilities.merge(:writer => false, :tester => false,
+        :collection_getset => :public, :collection_tester => true)
+
+      alias_method :plural_name, :name
+      def singular_name
+        @singular_name ||= Gorillib::Inflector.singularize(name.to_s).to_sym
+      end
+
+      def inscribe_methods(model)
+        item_type      = self.item_type
+        self.default   = ->{ Gorillib::Collection.new(item_type) }
+        raise "Plural and singular names must differ: #{self.plural_name}" if (singular_name == plural_name)
+        #
+        @visibilities[:writer] = false
+        model.__send__(:define_attribute_reader,   self.name, self.type, visibility(:reader))
+        model.__send__(:define_attribute_tester,   self.name, self.type, visibility(:tester))
+        #
+        model.__send__(:define_collection_receiver, self)
+        model.__send__(:define_collection_getset,   self)
+        model.__send__(:define_collection_tester,   self)
+      end
+    end
+
+  end
+end

data/lib/gorillib/collection/has_collection.rb

@@ -0,0 +1,31 @@
+module Gorillib
+  class Collection
+    module HasCollection
+
+      def has_collection(clxn_name, type, key_method=:name)
+        plural_name   = clxn_name
+        singular_name = Gorillib::Inflector.singularize(clxn_name.to_s).to_sym
+        
+        instance_variable_set("@#{plural_name}", Gorillib::Collection.new(type, key_method))
+
+        define_singleton_method(plural_name) do
+          instance_variable_get("@#{plural_name}") if instance_variable_defined?("@#{plural_name}")
+        end
+
+        define_singleton_method(singular_name) do |item_key, attrs={}, options={}, &block|
+          collection = instance_variable_get("@#{clxn_name}")
+          val = collection.fetch(item_key) do
+            attrs.merge!(key_method => item_key, :owner => self) if attrs.respond_to?(:merge!)
+            factory = options.fetch(:factory){ type }
+            new_val = factory.receive(attrs)
+            collection << new_val
+            new_val
+          end
+          val.instance_exec(&block) if block
+          val
+        end
+      end
+
+    end
+  end
+end

data/lib/gorillib/collection.rb

@@ -0,0 +1,129 @@
+require 'gorillib/metaprogramming/delegation'
+require 'gorillib/metaprogramming/class_attribute'
+
+module Gorillib
+  class Collection
+    # [String, Symbol] Method invoked on a new item to generate its collection key; :to_key by default
+    attr_accessor :key_method
+    # The default `key_method` invoked on a new item to generate its collection key
+    DEFAULT_KEY_METHOD = :to_key
+
+    # [Class, #receive] Factory for generating a new collection item.
+    class_attribute :factory, :instance_writer => false
+    singleton_class.class_eval{ protected :factory= }
+
+    # [{Symbol => Object}] The actual store of items, but not for you to mess with
+    attr_reader :clxn
+    protected   :clxn
+
+    delegate :[], :[]=, :delete, :fetch,                  :to => :clxn
+    delegate :keys, :values, :each_pair, :each_value,     :to => :clxn
+    delegate :has_key?, :include?, :length, :size, :empty?, :blank?, :to => :clxn
+
+    def initialize(factory=nil, key_method=DEFAULT_KEY_METHOD)
+      @key_method  = key_method
+      @factory     = factory unless factory.nil?
+      @clxn        = {}
+    end
+
+    # @return [Array] an array holding the items
+    def to_a    ; values    ; end
+    # @return [{Symbol => Object}] a hash of key=>item pairs
+    def to_hash ; clxn.dup  ; end
+
+    # Merge the new items in-place; given items clobber existing items
+    # @param  other [{Symbol => Object}, Array<Object>] a hash of key=>item pairs or a list of items
+    # @return [Gorillib::Collection] the collection
+    def merge!(other)
+      clxn.merge!( convert_collection(other) )
+      self
+    end
+    alias_method :concat,   :merge!
+    alias_method :receive!, :merge!
+
+    def self.receive(items, *args)
+      coll = new(*args)
+      coll.receive!(items)
+      coll
+    end
+
+    # Two collections are equal if they have the same class and their contents are equal
+    #
+    # @param [Gorillib::Collection, Object] other The other collection to compare
+    # @return [true, false] True if attributes are equal and other is instance of the same Class
+    def ==(other)
+      return false unless other.instance_of?(self.class)
+      clxn == other.send(:clxn)
+    end
+
+    # Merge the new items into a new collection; given items clobber existing items
+    # @param  other [{Symbol => Object}, Array<Object>] a hash of key=>item pairs or a list of items
+    # @return [Gorillib::Collection] a new merged collection
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def create(*args)
+      item = factory.receive(*args)
+      self << item
+      item
+    end
+
+    def find_or_create(key)
+      fetch(key){ create(key_method => key) }
+    end
+
+    # Adds an item in-place
+    # @return [Gorillib::Collection] the collection
+    def <<(val)
+      merge! [val]
+      self
+    end
+
+    # @return [String] string describing the collection's array representation
+    def to_s           ; to_a.to_s           ; end
+    # @return [String] string describing the collection's array representation
+    def inspect(detailed=true)
+      str = "c{ "
+      if detailed
+        str << clxn.map do |key, val|
+          "%-15s %s" % ["#{key}:", val.inspect]
+        end.join(",\n   ")
+      else
+        str << keys.join(", ")
+      end
+      str << " }"
+    end
+    # @return [Array] serializable array representation of the collection
+    def to_wire(options)
+      to_a.map{|el| el.respond_to?(:to_wire) ? el.to_wire(options) : el }
+    end
+    alias_method(:as_json, :to_wire)
+    # @return [String] JSON serialization of the collection's array representation
+    def to_json(*args)
+      p [self, options]
+      to_wire(*args).to_json(*args)
+    end
+
+  protected
+
+    def convert_value(val)
+      return val unless factory
+      return nil if val.nil?
+      factory.receive(val)
+    end
+
+    # - if the given collection responds_to `to_hash`, it is merged into the internal collection; each hash key *must* match the id of its value or results are undefined.
+    # - otherwise, it merges a hash generates from the id/value pairs of each object in the given collection.
+    def convert_collection(cc)
+      return cc.to_hash if cc.respond_to?(:to_hash)
+      cc.inject({}) do |acc, val|
+        val      = convert_value(val)
+        key      = val.public_send(key_method).to_sym
+        acc[key] = val
+        acc
+      end
+    end
+  end
+
+end

data/lib/gorillib/configurable.rb

@@ -0,0 +1,28 @@
+require 'configliere'
+require 'gorillib/builder'
+require 'gorillib/string/inflections'
+
+module Gorillib    
+  module Configurable
+    extend Gorillib::Concern
+    include Gorillib::Builder
+
+    module ClassMethods
+      def receive(attrs = {}, &blk)            
+        conf = settings.load_configuration_in_order!(configuration_scope.to_s)
+        super(attrs.merge(conf), &blk)
+      end
+
+      def config(name, type, options = {})
+        field(name, type, options)
+      end
+    end
+    
+    included do
+      self.class_attribute(:configuration_scope, :settings)
+      self.configuration_scope = self.to_s.underscore.to_sym
+      self.settings            = Configliere::Param.new.use(:commandline, :config_file)
+    end
+    
+  end
+end

data/lib/gorillib/exception/confidence.rb

@@ -0,0 +1,17 @@
+module Kernel
+  def assert(value, message="Assertion failed", error=StandardError)
+    raise error, message, caller unless value
+  end
+end
+
+class NullObject
+  def method_missing(*args, &block)
+    self
+  end
+
+  def nil?; true; end
+end
+
+def Maybe(value)
+  value.nil? ? NullObject.new : value
+end

data/lib/gorillib/exception/raisers.rb

@@ -0,0 +1,78 @@
+Exception.class_eval do
+  # @return [Array] __FILE__, __LINE__, description
+  def self.caller_parts
+    caller_line = caller[1]
+    mg = %r{\A([^:]+):(\d+):in \`([^\']+)\'\z}.match(caller_line) or return [caller_line, 1, 'unknown']
+    [mg[1], mg[2].to_i, mg[3]]
+  end
+
+  #
+  # @note !! Be sure to rescue the call to this method; few things suck worse than debugging your rescue blocks/
+  def polish(extra_info)
+    filename, _, method_name = self.class.caller_parts
+    method_name.gsub!(/rescue in /, '')
+    most_recent_line = backtrace.detect{|line| line.include?(filename) && line.include?(method_name) }
+    most_recent_line.sub!(/'$/, " for #{extra_info}'"[0..300])
+  end
+
+end
+
+ArgumentError.class_eval do
+  # Raise an error just like Ruby's native message if the array of arguments
+  # doesn't match the expected length or range of lengths.
+  #
+  # @example want `getset(:foo)` to be different from `getset(:foo, nil)`
+  #   def getset(key, *args)
+  #     ArgumentError.check_arity!(args, 0..1)
+  #     return self[key] if args.empty?
+  #     self[key] = args.first
+  #   end
+  #
+  # @overload check_arity!(args, n)
+  #   @param [Array]     args splat args as handed to the caller
+  #   @param [Integer]   val  expected length
+  # @overload check_arity!(args, x..y)
+  #   @param [Array]     args splat args as handed to the caller
+  #   @param [#include?] val  expected range/list/set of lengths
+  # @raise ArgumentError when there are
+  def self.check_arity!(args, val)
+    allowed_arity = val.is_a?(Integer) ? (val..val) : val
+    return true if allowed_arity.include?(args.length)
+    raise self.new("wrong number of arguments (#{args.length} for #{val})")
+  end
+
+  # Raise an error just like Ruby's native message if there are fewer arguments
+  # than expected
+  #
+  # @example want to use splat args, requiring at least one
+  #   def assemble_path(*pathsegs)
+  #     ArgumentError.arity_at_least!(pathsegs, 1)
+  #     # ...
+  #   end
+  #
+  # @param [Array]     args splat args as handed to the caller
+  # @param [Integer]   val  minimum expected length
+  def self.arity_at_least!(args, min_arity)
+    check_arity!(args, min_arity .. Float::INFINITY)
+  end
+end
+
+NoMethodError.class_eval do
+  MESSAGE = "undefined method `%s' for %s:%s"
+
+  def self.undefined_method(obj)
+    file, line, meth = caller_parts
+    self.new(MESSAGE % [meth, obj, obj.class])
+  end
+
+  def self.unimplemented_method(obj)
+    file, line, meth = caller_parts
+    self.new("#{MESSAGE} -- not implemented yet" % [meth, obj, obj.class])
+  end
+
+  def self.abstract(obj)
+    file, line, meth = caller_parts
+    self.new("#{MESSAGE} -- must be implemented by the subclass" % [meth, obj, obj.class])
+  end
+
+end