doodle 0.2.2 → 0.2.3

data/lib/doodle/comparable.rb

@@ -0,0 +1,8 @@
+class Doodle
+  # doodles are compared (sorted) on values
+  module Comparable
+    def <=>(o)
+      doodle.values <=> o.doodle.values
+    end
+  end
+end

data/lib/doodle/conversion.rb

@@ -0,0 +1,80 @@
+class Doodle
+  module ConversionHelper
+    # if block passed, define a conversion from class
+    # if no args, apply conversion to arguments
+    def from(*args, &block)
+      Doodle::Debug.d { [self, args, block]}
+      #p [:from, self, args]
+      if block_given?
+        # set the rule for each arg given
+        args.each do |arg|
+          __doodle__.local_conversions[arg] = block
+        end
+      else
+        convert(self, *args)
+      end
+    end
+
+    # convert a value according to conversion rules
+    # FIXME: move
+    def convert(owner, *args)
+      #pp( { :convert => 1, :owner => owner, :args => args, :conversions => __doodle__.conversions } )
+      begin
+        args = args.map do |value|
+          #!p [:convert, 2, value]
+          if (converter = __doodle__.conversions[value.class])
+            #p [:convert, 3, value, self, caller]
+            value = converter[value]
+            #!p [:convert, 4, value]
+          else
+            #!p [:convert, 5, value]
+            # try to find nearest ancestor
+            this_ancestors = value.class.ancestors
+            #!p [:convert, 6, this_ancestors]
+            matches = this_ancestors & __doodle__.conversions.keys
+            #!p [:convert, 7, matches]
+            indexed_matches = matches.map{ |x| this_ancestors.index(x)}
+            #!p [:convert, 8, indexed_matches]
+            if indexed_matches.size > 0
+              #!p [:convert, 9]
+              converter_class = this_ancestors[indexed_matches.min]
+              #!p [:convert, 10, converter_class]
+              if converter = __doodle__.conversions[converter_class]
+                #!p [:convert, 11, converter]
+                value = converter[value]
+                #!p [:convert, 12, value]
+              end
+            else
+              #!p [:convert, 13, :kind, kind, name, value]
+              mappable_kinds = kind.select{ |x| x <= Doodle::Core }
+              #!p [:convert, 13.1, :kind, kind, mappable_kinds]
+              if mappable_kinds.size > 0
+                mappable_kinds.each do |mappable_kind|
+                  #!p [:convert, 14, :kind_is_a_doodle, value.class, mappable_kind, mappable_kind.doodle.conversions, args]
+                  if converter = mappable_kind.doodle.conversions[value.class]
+                    #!p [:convert, 15, value, mappable_kind, args]
+                    value = converter[value]
+                    break
+                  else
+                    #!p [:convert, 16, :no_conversion_for, value.class]
+                  end
+                end
+              else
+                #!p [:convert, 17, :kind_has_no_conversions]
+              end
+            end
+          end
+          #!p [:convert, 18, value]
+          value
+        end
+      rescue Exception => e
+        owner.__doodle__.handle_error name, ConversionError, "#{e.message}", Doodle::Utils.doodle_caller
+      end
+      if args.size > 1
+        args
+      else
+        args.first
+      end
+    end
+  end
+end

data/lib/doodle/core.rb

@@ -0,0 +1,42 @@
+class Doodle
+  module ClassMethods
+    # provide somewhere to hold thread-specific context information
+    # (I'm claiming the :doodle_xxx namespace)
+    def context
+      Thread.current[:doodle_context] ||= []
+    end
+    def parent
+      context[-1]
+    end
+  end
+
+  extend ClassMethods
+
+  # Place to hold refs to built-in classes that need special handling
+  module BuiltIns
+    BUILTINS = [String, Hash, Array]
+  end
+
+  # Include Doodle::Core if you want to derive from another class
+  # but still get Doodle goodness in your class (including Factory
+  # methods).
+  module Core
+    module ModuleMethods
+      def included(other)
+        super
+        other.module_eval {
+          # FIXME: this is getting a bit arbitrary
+          include Equality
+          include Comparable
+          include Inherited
+          inherit BaseMethods
+        }
+      end
+    end
+    extend ModuleMethods
+  end
+
+  include Core
+
+end
+

data/lib/doodle/datatype-holder.rb

@@ -0,0 +1,39 @@
+class Doodle
+  # implements the #doodle directive
+  class DataTypeHolder
+    attr_accessor :klass
+
+    def initialize(klass, &block)
+      @klass = klass
+      instance_eval(&block) if block_given?
+    end
+
+    def define(name, params, block, type_params, &type_block)
+      @klass.class_eval {
+        td = has(name, type_params.merge(params), &type_block)
+        td.instance_eval(&block) if block
+        td
+      }
+    end
+
+    def has(*args, &block)
+      @klass.class_eval { has(*args, &block) }
+    end
+
+    def must(*args, &block)
+      @klass.class_eval { must(*args, &block) }
+    end
+
+    def from(*args, &block)
+      @klass.class_eval { from(*args, &block) }
+    end
+
+    def arg_order(*args, &block)
+      @klass.class_eval { arg_order(*args, &block) }
+    end
+
+    def doc(*args, &block)
+      @klass.class_eval { doc(*args, &block) }
+    end
+  end
+end

data/lib/doodle/debug.rb

@@ -0,0 +1,20 @@
+class Doodle
+  # debugging utilities
+  module Debug
+    class << self
+      # Robert Klemme, (ruby-talk 205150), (ruby-talk 205950)
+      def calling_method(level = 1)
+        caller[level] =~ /`([^']*)'/ and $1
+      end
+
+      def this_method
+        calling_method
+      end
+
+      # output result of block if ENV['DEBUG_DOODLE'] set
+      def d(&block)
+        puts(calling_method + ": " + block.call.inspect) if ENV['DEBUG_DOODLE']
+      end
+    end
+  end
+end

data/lib/doodle/deferred.rb

@@ -0,0 +1,13 @@
+class Doodle
+  # save a block for later execution
+  class DeferredBlock
+    attr_accessor :block
+    def initialize(arg_block = nil, &block)
+      arg_block = block if block_given?
+      @block = arg_block
+    end
+    def call(*a, &b)
+      block.call(*a, &b)
+    end
+  end
+end

data/lib/doodle/equality.rb

@@ -0,0 +1,21 @@
+class Doodle
+  # two doodles of the same class with the same attribute values are
+  # considered equal
+  module Equality
+    def eql?(o)
+      #       p [:comparing, self.class, o.class, self.class == o.class]
+      #       p [:values, self.doodle.values, o.doodle.values, self.doodle.values == o.doodle.values]
+      #       p [:attributes, doodle.attributes.map { |k, a| [k, send(k).==(o.send(k))] }]
+      res = self.class == o.class &&
+        #self.doodle.values == o.doodle.values
+        # short circuit comparison
+        doodle.attributes.all? { |k, a| send(k).==(o.send(k)) }
+      #       p [:res, res]
+      res
+    end
+    def ==(o)
+      eql?(o)
+    end
+  end
+end
+

data/lib/doodle/exceptions.rb

@@ -0,0 +1,29 @@
+class Doodle
+  # error handling
+  @@raise_exception_on_error = true
+  def self.raise_exception_on_error
+    @@raise_exception_on_error
+  end
+  def self.raise_exception_on_error=(tf)
+    @@raise_exception_on_error = tf
+  end
+
+  # internal error raised when a default was expected but not found
+  class NoDefaultError < Exception
+  end
+  # raised when a validation rule returns false
+  class ValidationError < Exception
+  end
+  # raised when an unknown parameter is passed to initialize
+  class UnknownAttributeError < Exception
+  end
+  # raised when a conversion fails
+  class ConversionError < Exception
+  end
+  # raised when arg_order called with incorrect arguments
+  class InvalidOrderError < Exception
+  end
+  # raised when try to set a readonly attribute after initialization
+  class ReadOnlyError < Exception
+  end
+end

data/lib/doodle/factory.rb

@@ -0,0 +1,91 @@
+class Doodle
+  # A factory function is a function that has the same name as
+  # a class which acts just like class.new. For example:
+  #   Cat(:name => 'Ren')
+  # is the same as:
+  #   Cat.new(:name => 'Ren')
+  # As the notion of a factory function is somewhat contentious [xref
+  # ruby-talk], you need to explicitly ask for them by including Factory
+  # in your base class:
+  #   class Animal < Doodle
+  #     include Factory
+  #   end
+  #   class Dog < Animal
+  #   end
+  #   stimpy = Dog(:name => 'Stimpy')
+  # etc.
+  module Factory
+    RX_IDENTIFIER = /^[A-Za-z_][A-Za-z_0-9]+\??$/
+    module ClassMethods
+      # create a factory function in appropriate module for the specified class
+      def factory(konst)
+        #p [:factory, :ancestors, konst, konst.ancestors]
+        #p [:factory, :lookup, Module.nesting]
+        name = konst.to_s
+        #p [:factory, :name, name]
+        anon_class = false
+        if name =~ /#<Class:0x[a-fA-F0-9]+>::/
+            #p [:factory_anon_class, name]
+            anon_class = true
+        end
+        names = name.split(/::/)
+        name = names.pop
+        # TODO: the code below is almost the same - refactor
+        #p [:factory, :names, names, name]
+        if names.empty? && !anon_class
+          #p [:factory, :top_level_class]
+          # top level class - should be available to all
+          parent_class = Object
+          method_defined = begin
+                             method(name)
+                             true
+                           rescue Object
+                             false
+                           end
+
+          if name =~ Factory::RX_IDENTIFIER && !method_defined && !parent_class.respond_to?(name) && !eval("respond_to?(:#{name})", TOPLEVEL_BINDING)
+            eval("def #{ name }(*args, &block); ::#{name}.new(*args, &block); end", ::TOPLEVEL_BINDING, __FILE__, __LINE__)
+          end
+        else
+          #p [:factory, :other_level_class]
+          parent_class = Object
+          if !anon_class
+            parent_class = names.inject(parent_class) {|c, n| c.const_get(n)}
+            #p [:factory, :parent_class, parent_class]
+            if name =~ Factory::RX_IDENTIFIER && !parent_class.respond_to?(name)
+              # FIXME: find out why define_method version not working
+              parent_class.module_eval("def self.#{name}(*args, &block); #{name}.new(*args, &block); end", __FILE__, __LINE__)
+            end
+          else
+            # NOTE: ruby 1.9.1 specific
+            parent_class_name = names.join('::')
+            #p [:factory, :parent_class_name, parent_class_name]
+            #p [:parent_class_name, parent_class_name]
+            # FIXME: this is truly horrible...
+            hex_object_id = parent_class_name.match(/:(0x[a-zA-Z0-9]+)/)[1]
+            oid = hex_object_id.to_i(16) >> 1
+            #             p [:object_id, oid, hex_object_id, hex_object_id.to_i(16) >> 1]
+            parent_class = ObjectSpace._id2ref(oid)
+
+            #p [:parent_object_id, parent_class.object_id, names, parent_class, parent_class_name, parent_class.name]
+            #             p [:names, :oid, "%x" % (oid << 1), :konst, konst, :pc, parent_class, :names, names, :self, self]
+            if name =~ Factory::RX_IDENTIFIER && !parent_class.respond_to?(name) && parent_class.const_defined?(name)
+              #p [:context, context]
+              parent_class.module_eval("def #{name}(*args, &block); #{name}.new(*args, &block); end", __FILE__, __LINE__)
+            end
+          end
+          # TODO: check how many times this is being called
+        end
+      end
+
+      # inherit the factory function capability
+      def included(other)
+        #p [:included, other]
+        super
+        # make +factory+ method available
+        factory other
+      end
+    end
+    extend ClassMethods
+  end
+end

data/lib/doodle/getter-setter.rb

@@ -0,0 +1,154 @@
+class Doodle
+  module GetterSetter
+    # either get an attribute value (if no args given) or set it
+    # (using args and/or block)
+    # FIXME: move
+    def getter_setter(name, *args, &block)
+      #p [:getter_setter, name]
+      name = name.to_sym
+      if block_given? || args.size > 0
+        #!p [:getter_setter, :setter, name, *args]
+        _setter(name, *args, &block)
+      else
+        #!p [:getter_setter, :getter, name]
+        _getter(name)
+      end
+    end
+    private :getter_setter
+
+    # get an attribute by name - return default if not otherwise defined
+    # FIXME: init deferred blocks are not getting resolved in all cases
+    def _getter(name, &block)
+      begin
+        #p [:_getter, name]
+        ivar = "@#{name}"
+        if instance_variable_defined?(ivar)
+          #p [:_getter, :instance_variable_defined, name, ivar, instance_variable_get(ivar)]
+          instance_variable_get(ivar)
+        else
+          # handle default
+          # Note: use :init => value to cover cases where defaults don't work
+          # (e.g. arrays that disappear when you go out of scope)
+          att = __doodle__.lookup_attribute(name)
+          # special case for class/singleton :init
+          if att && att.optional?
+            optional_value = att.init_defined? ? att.init : att.default
+            #p [:optional_value, optional_value]
+            case optional_value
+            when DeferredBlock
+              #p [:deferred_block]
+              v = instance_eval(&optional_value.block)
+            when Proc
+              v = instance_eval(&optional_value)
+            else
+              v = optional_value
+            end
+            if att.init_defined?
+              _setter(name, v)
+            end
+            v
+          else
+            # This is an internal error (i.e. shouldn't happen)
+            __doodle__.handle_error name, NoDefaultError, "'#{name}' has no default defined", Doodle::Utils.doodle_caller
+          end
+        end
+      rescue Object => e
+        __doodle__.handle_error name, e, e.to_s, Doodle::Utils.doodle_caller
+      end
+    end
+    private :_getter
+
+    def after_update(params)
+    end
+
+    # set an instance variable by symbolic name and call after_update if changed
+    def ivar_set(name, *args)
+      ivar = "@#{name}"
+      if instance_variable_defined?(ivar)
+        old_value = instance_variable_get(ivar)
+      else
+        old_value = nil
+      end
+      instance_variable_set(ivar, *args)
+      new_value = instance_variable_get(ivar)
+      if new_value != old_value
+        #pp [Doodle, :after_update, { :instance => self, :name => name, :old_value => old_value, :new_value => new_value }]
+        after_update :instance => self, :name => name, :old_value => old_value, :new_value => new_value
+      end
+    end
+    private :ivar_set
+
+    # set an attribute by name - apply validation if defined
+    # FIXME: move
+    def _setter(name, *args, &block)
+      ##DBG: Doodle::Debug.d { [:_setter, name, args] }
+      #p [:_setter, name, *args]
+      att = __doodle__.lookup_attribute(name)
+      if att && __doodle__.validation_on && att.readonly
+        raise Doodle::ReadOnlyError, "Trying to set a readonly attribute: #{att.name}", Doodle::Utils.doodle_caller
+      end
+      if block_given?
+        # if a class has been defined, let's assume it can take a
+        # block initializer (test that it's a Doodle or Proc)
+        if att.kind && !att.abstract && klass = att.kind.first
+          if [Doodle, Proc].any?{ |c| klass <= c }
+            # p [:_setter, '# 1 converting arg to value with kind ' + klass.to_s]
+            args = [klass.new(*args, &block)]
+          else
+            __doodle__.handle_error att.name, ArgumentError, "#{klass} #{att.name} does not take a block initializer", Doodle::Utils.doodle_caller
+          end
+        else
+          # this is used by init do ... block
+          args.unshift(DeferredBlock.new(block))
+        end
+      end
+      if att # = __doodle__.lookup_attribute(name)
+        if att.kind && !att.abstract && klass = att.kind.first
+          if !args.first.kind_of?(klass) && [Doodle].any?{ |c| klass <= c }
+            #p [:_setter, "#2 converting arg #{att.name} to value with kind #{klass.to_s}"]
+            #p [:_setter, args]
+            begin
+              args = [klass.new(*args, &block)]
+            rescue Object => e
+              __doodle__.handle_error att.name, e.class, e.to_s, Doodle::Utils.doodle_caller
+            end
+          end
+        end
+        #p [:_setter, :got_att1, name, ivar, *args]
+        v = ivar_set(name, att.validate(self, *args))
+
+        #p [:_setter, :got_att2, name, ivar, :value, v]
+        #v = instance_variable_set(ivar, *args)
+      else
+        #p [:_setter, :no_att, name, *args]
+        ##DBG: Doodle::Debug.d { [:_setter, "no attribute"] }
+        v = ivar_set(name, *args)
+      end
+      validate!(false)
+      v
+    end
+    private :_setter
+
+    # define a getter_setter
+    # fixme: move
+    def define_getter_setter(name, params = { }, &block)
+      # need to use string eval because passing block
+      sc_eval "def #{name}(*args, &block); getter_setter(:#{name}, *args, &block); end", __FILE__, __LINE__
+      sc_eval "def #{name}=(*args, &block); _setter(:#{name}, *args); end", __FILE__, __LINE__
+
+      # this is how it should be done (in 1.9)
+      #       module_eval {
+      #         define_method name do |*args, &block|
+      #           getter_setter(name.to_sym, *args, &block)
+      #         end
+      #         define_method "#{name}=" do |*args, &block|
+      #           _setter(name.to_sym, *args, &block)
+      #         end
+      #       }
+    end
+    private :define_getter_setter
+
+
+
+  end
+end