doodle 0.2.2 → 0.2.3

data/lib/doodle/app.rb

@@ -67,6 +67,7 @@ class Doodle
     class Filename < Option
       doodle do
         boolean :existing, :default => false, :doc => "set to true if file must exist"
+        boolean :expand, :default => false, :doc => "set to true if you want to have the filename expanded"
       end
     end
 
@@ -176,6 +177,11 @@ class Doodle
               File.exist?(s)
             end
           end
+          if da.expand
+            from String do |s|
+              File.expand_path(s)
+            end
+          end
         end
       end
       # expect an on/off flag, e.g. -b

data/lib/doodle/attribute.rb

@@ -0,0 +1,165 @@
+class Doodle
+  # Attribute is itself a Doodle object that is created by #has and
+  # added to the #attributes collection in an object's DoodleInfo
+  #
+  # It is used to provide a context for defining #must and #from rules
+  #
+  class DoodleAttribute < Doodle
+    # note: using extend with a module causes an infinite loop in 1.9
+    # hence the inline
+
+    module ClassMethods
+      # rewrite rules for the argument list to #has
+      def params_from_args(owner, *args)
+        Doodle::Debug.d { [owner, args] }
+        key_values, positional_args = args.partition{ |x| x.kind_of?(Hash)}
+        params = { }
+        if positional_args.size > 0
+          name = positional_args.shift
+          case name
+            # has Person --> has :person, :kind => Person
+          when Class
+            params[:name] = Utils.snake_case(name.to_s.split(/::/).last)
+            params[:kind] = name
+          else
+            params[:name] = name.to_s.to_sym
+          end
+        end
+        params = key_values.inject(params){ |acc, item| acc.merge(item)}
+        #DBG: Doodle::Debug.d { [:has, self, self.class, params] }
+        if !params.key?(:name)
+          __doodle__.handle_error name, ArgumentError, "#{self.class} must have a name", Doodle::Utils.doodle_caller
+          params[:name] = :__ERROR_missing_name__
+        else
+          # ensure that :name is a symbol
+          params[:name] = params[:name].to_sym
+        end
+        name = params[:name]
+        __doodle__.handle_error name, ArgumentError, "#{self.class} has too many arguments", Doodle::Utils.doodle_caller if positional_args.size > 0
+
+        if collector = params.delete(:collect)
+          if !params.key?(:using)
+            if params.key?(:key)
+              params[:using] = KeyedAttribute
+            else
+              params[:using] = AppendableAttribute
+            end
+          end
+          # this in generic CollectorAttribute class
+          # collector from(Hash)
+
+          # TODO: rework this to allow multiple classes and mappings
+          #p [:collector, collector, params, params[:init].kind_of?(Class)]
+          # FIXME: collector
+          if collector.kind_of?(Hash)
+            collector_spec = collector
+            #collector_name, collector_class = collector.to_a[0]
+          elsif collector.kind_of?(Array) && collector.all? { |i| i.kind_of?(Hash) }
+            collector_spec = collector.inject(OrderedHash.new) { |hash, item|
+              item.keys.each do |key|
+                hash[key] = item[key]
+              end
+              hash
+            }
+          else
+            collectors = [collector].flatten
+            collector_spec = collectors.inject(OrderedHash.new) do |hash, klass|
+              collector_class = klass.to_s
+              #p [:collector_klass, collector_klass]
+              collector_name = Utils.snake_case(collector_class.split(/::/).last)
+              #p [:collector_name, collector_class, collector_name]
+              # FIXME: sanitize class name for 1.9 (make this a Utils function)
+              collector_class = collector_class.gsub(/#<Class:0x[a-fA-F0-9]+>::/, '')
+              # if Capitalized word given, treat as classname and create
+              # collector for specific class
+              if collector_class !~ /^[A-Z]/
+                collector_class = nil
+              end
+              hash[collector_name] = collector_class
+              hash
+            end
+            #!p [:collector_klass, collector_klass, params[:init]]
+          end
+          params[:collector_spec] = collector_spec
+        end
+        params[:doodle_owner] = owner
+        #p [:params, owner, params]
+        params
+      end
+    end
+    extend ClassMethods
+
+    # must define these methods before using them in #has below
+
+    # hack: bump off +validate!+ for Attributes - maybe better way of doing
+    # this however, without this, tries to validate Attribute to :kind
+    # specified, e.g. if you have
+    #
+    #   has :date, :kind => Date
+    #
+    # it will fail because Attribute is not a kind of Date -
+    # obviously, I have to think about this some more :S
+    #
+    # at least, I could hand roll a custom validate! method for Attribute
+    #
+    def validate!(all = true)
+    end
+
+    # has default been defined?
+    def default_defined?
+      ivar_defined?(:default)
+    end
+
+    # has default been defined?
+    def init_defined?
+      ivar_defined?(:init)
+    end
+
+    # is this attribute optional? true if it has a default defined for it
+    def optional?
+      default_defined? or init_defined?
+    end
+
+    # an attribute is required if it has no default or initial value defined for it
+    def required?
+      # d { [:default?, self.class, self.name, instance_variable_defined?("@default"), @default] }
+      !optional?
+    end
+
+    # special case - not an attribute
+    define_getter_setter :doodle_owner
+
+    # temporarily fake existence of abstract attribute - later has
+    # :abstract overrides this
+    def abstract
+      @abstract = false
+    end
+
+    # temporarily fake existence of readonly attribute
+    def readonly
+      false
+    end
+
+    # name of attribute
+    has :name, :kind => Symbol do
+      from String do |s|
+        s.to_sym
+      end
+    end
+
+    # default value (can be a block)
+    has :default, :default => nil
+
+    # initial value
+    has :init, :default => nil
+
+    # documentation
+    has :doc, :default => ""
+
+    # don't try to initialize from this class
+    remove_method(:abstract) # because we faked it earlier - remove to avoid redefinition warning
+    has :abstract, :default => false
+    remove_method(:readonly) # because we faked it earlier - remove to avoid redefinition warning
+    has :readonly, :default => false
+  end
+end

data/lib/doodle/base.rb

@@ -0,0 +1,180 @@
+class Doodle
+  # the core module of Doodle - however, to get most facilities
+  # provided by Doodle without inheriting from Doodle, include
+  # Doodle::Core, not this module
+  module BaseMethods
+    include Singleton
+    include SmokeAndMirrors
+    include ToHash
+    include ModMarshal
+    include GetterSetter
+    include ValidationHelper
+    include ConversionHelper
+
+    # NOTE: can't do either of these
+
+    #     include Equality
+    #     include Comparable
+
+    #     def self.included(other)
+    #       other.module_eval {
+    #         include Equality
+    #         include Comparable
+    #       }
+    #     end
+
+    # this is the only way to get at internal values. Note: this is
+    # initialized on the fly rather than in #initialize because
+    # classes and singletons don't call #initialize
+    def __doodle__
+      @__doodle__ ||= DoodleInfo.new(self)
+    end
+    protected :__doodle__
+
+    # set up global datatypes
+    def datatypes(*mods)
+      mods.each do |mod|
+        DataTypeHolder.class_eval { include mod }
+      end
+    end
+
+    # vector through this method to get to doodle info or enable global
+    # datatypes and provide an interface that allows you to add your own
+    # datatypes to this declaration
+    def doodle(*mods, &block)
+      if mods.size == 0 && !block_given?
+        __doodle__
+      else
+        dh = Doodle::DataTypeHolder.new(self)
+        mods.each do |mod|
+          dh.extend(mod)
+        end
+        dh.instance_eval(&block)
+      end
+    end
+
+    # +doc+ add docs to doodle class or attribute
+    def doc(*args, &block)
+      if args.size > 0
+        @doc = *args
+      else
+        @doc
+      end
+    end
+    alias :doc= :doc
+
+    # +has+ is an extended +attr_accessor+
+    #
+    # simple usage - just like +attr_accessor+:
+    #
+    #  class Event
+    #    has :date
+    #  end
+    #
+    # set default value:
+    #
+    #  class Event
+    #    has :date, :default => Date.today
+    #  end
+    #
+    # set lazily evaluated default value:
+    #
+    #  class Event
+    #    has :date do
+    #      default { Date.today }
+    #    end
+    #  end
+    #
+    def has(*args, &block)
+      Doodle::Debug.d { [:args, self, self.class, args] }
+      params = DoodleAttribute.params_from_args(self, *args)
+      Doodle::Debug.d { [:params, self, params] }
+      # get specialized attribute class or use default
+      attribute_class = params.delete(:using) || DoodleAttribute
+
+      # could this be handled in DoodleAttribute?
+      # define getter setter before setting up attribute
+      define_getter_setter params[:name], params, &block
+      #p [:attribute, attribute_class, params]
+      attr = __doodle__.local_attributes[params[:name]] = attribute_class.new(params, &block)
+
+      # FIXME: not sure this is really the right place for this (but
+      # right now the only place I can get it to work :)
+      if from_defined = params[:from]
+        from_defined.each do |k, v|
+          Doodle::Debug.d { [:defining, self, k, v]}
+          attr.instance_eval { from k, &v }
+        end
+      end
+
+      if must_defined = params[:must]
+        must_defined.each do |k, v|
+          attr.instance_eval { must k, &v }
+        end
+      end
+
+      attr
+    end
+
+    # define order for positional arguments
+    def arg_order(*args)
+      if args.size > 0
+        begin
+          args = args.uniq
+          args.each do |x|
+            __doodle__.handle_error :arg_order, ArgumentError, "#{x} not a Symbol", Doodle::Utils.doodle_caller if !(x.class <= Symbol)
+            __doodle__.handle_error :arg_order, NameError, "#{x} not an attribute name", Doodle::Utils.doodle_caller if !doodle.attributes.keys.include?(x)
+          end
+          __doodle__.arg_order = args
+        rescue Exception => e
+          __doodle__.handle_error :arg_order, InvalidOrderError, e.to_s, Doodle::Utils.doodle_caller
+        end
+      else
+        __doodle__.arg_order + (__doodle__.attributes.keys - __doodle__.arg_order)
+      end
+    end
+
+    # return true if instance variable +name+ defined
+    # FIXME: move
+    def ivar_defined?(name)
+      instance_variable_defined?("@#{name}")
+    end
+    private :ivar_defined?
+
+    # get an instance variable by symbolic name
+    def ivar_get(name)
+      instance_variable_get("@#{name}")
+    end
+
+    # return true if attribute has default defined and not yet been
+    # assigned to (i.e. still has default value)
+    def default?(name)
+      # FIXME: should this be in DoodleInfo or here?
+      __doodle__.attributes[name.to_sym].optional? && !ivar_defined?(name)
+    end
+
+    # return true if attribute has been assigned to
+    def assigned?(name)
+      ivar_defined?(name)
+    end
+
+    # object can be initialized from a mixture of positional arguments,
+    # hash of keyword value pairs and a block which is instance_eval'd
+    def initialize(*args, &block)
+      built_in = Doodle::BuiltIns::BUILTINS.select{ |x| self.kind_of?(x) }.first
+      if built_in
+        super
+      end
+      __doodle__.validation_on = true
+      #p [:doodle_parent, Doodle.parent, caller[-1]]
+      Doodle.context.push(self)
+      __doodle__.defer_validation do
+        __doodle__.update(*args, &block)
+      end
+      Doodle.context.pop
+      #p [:doodle, __doodle__.__inspect__]
+      #p [:doodle, __doodle__.attributes]
+      #p [:doodle_parent, __doodle__.parent]
+    end
+  end
+end

data/lib/doodle/collector-1.9.rb

@@ -0,0 +1,72 @@
+# 1.8.7+ versions
+class Doodle
+  class AppendableAttribute
+    def define_collector
+      # FIXME: don't use eval in 1.9+
+      #name = self.name
+      #collector_name = self.collector_name
+      #collector_class = self.collector_class
+      this = self
+      if collector_class.nil?
+        doodle_owner.sc_eval do
+          define_method this.collector_name do |*args, &block|
+            collection = send(this.name)
+            #p [this.collector_name, 1, this.name, args]
+            # unshift the block onto args so not consumed by <<
+            #args.unshift(block) if block_given?
+            collection.<<(*args, &block)
+          end
+        end
+      else
+        doodle_owner.sc_eval do
+          define_method this.collector_name do |*args, &block|
+            collection = send(this.name)
+            #p [this.collector_name, 1, this.name, args]
+            #args.unshift(block) if block_given?
+            if args.size > 0 and args.all?{|x| x.kind_of?(this.collector_class)}
+              collection.<<(*args, &block)
+            else
+              collection << this.collector_class.new(*args, &block)
+              #collection.<<(*args)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class KeyedAttribute
+    def define_collector
+      # save ref to self for use in closure
+      this = self
+      if this.collector_class.nil?
+        doodle_owner.sc_eval do
+          #p [:defining, this.collector_name]
+          define_method this.collector_name do |*args, &block|
+            #p [this.collector_name, 1, args]
+            collection = send(this.name)
+            args.each do |arg|
+              collection[arg.send(key)] = arg
+            end
+          end
+        end
+      else
+        doodle_owner.sc_eval do
+          #p [:defining, this.collector_name]
+          define_method this.collector_name do |*args, &block|
+            #p [this.collector_name, 2, args]
+            collection = send(this.name)
+            if args.size > 0 and args.all?{|x| x.kind_of?(this.collector_class)}
+              args.each do |arg|
+                collection[arg.send(this.key)] = arg
+              end
+            else
+              obj = this.collector_class.new(*args, &block)
+              collection[obj.send(this.key)] = obj
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doodle/collector.rb

@@ -0,0 +1,191 @@
+class Doodle
+
+  def self.TypedArray(*klasses)
+    typed_class = Class.new(NormalizedArray) do
+      define_method :normalize_value do |v|
+        if !klasses.any?{ |klass| v.kind_of?(klass) }
+          raise TypeError, "#{self.class}: #{v.class}(#{v.inspect}) is not a kind of #{klasses.map{ |c| c.to_s }.join(', ')}", [caller[-1]]
+        end
+        v
+      end
+    end
+    #p [:creating_class, typed_class]
+    typed_class
+  end
+
+  # base class for attribute collector classes
+  class AttributeCollector < DoodleAttribute
+    # FIXME: collector
+    has :collector_spec, :init => { }
+
+    def create_collection
+      if self.init.kind_of?(Class)
+        #p [:create_collection, :class]
+        collection = self.init.new
+      else
+        #p [:create_collection, :clone]
+        collection = self.init.clone
+      end
+      #p [:create_collection, collection]
+      collection
+    end
+    private :create_collection
+
+    def resolve_collector_class
+      # FIXME: collector - perhaps don't allow non-class collectors - should be resolved by this point
+      # perhaps do this in init?
+      collector_spec.each do |k, v|
+        if !v.kind_of?(Class)
+          collector_spec[k] = Doodle::Utils.const_resolve(v)
+        end
+      end
+    end
+
+    def resolve_value(value)
+      klasses = collector_spec.values
+      # FIXME: collector - find applicable collector class
+      if klasses.any? { |x| value.kind_of?(x) }
+        # no change required
+        #p [:resolve_value, :value, value]
+        value
+      elsif collector_class = klasses.select { |klass| klass.__doodle__.conversions.key?(value.class) }.first
+        # if the collector_class has a specific conversion for this value class
+        #p [:resolve_value, :collector_class_from, value]
+        collector_class.from(value)
+      else
+        collector_class = klasses.first
+        # try to instantiate collector_class using raw value
+        #p [:resolve_value, :collector_class_new, value]
+        collector_class.new(value)
+      end
+    end
+
+    def initialize(*args, &block)
+      #p [self.class, :initialize]
+      super
+      define_collector
+      from Hash do |hash|
+        # FIXME: collector - my bogon detector just went off the scale - I forget why I have to do this here... :/
+        # oh yes - because I allow forward references using symbols or strings
+        resolve_collector_class
+        collection = create_collection
+        hash.inject(collection) do |h, (key, value)|
+          h[key] = resolve_value(value)
+          h
+        end
+      end
+      from Enumerable do |enum|
+        #p [:enum, Enumerable]
+        # FIXME: collector
+        resolve_collector_class
+        # this is not very elegant but String is a classified as an
+        # Enumerable in 1.8.x (but behaves differently)
+        if enum.kind_of?(String) && self.init.kind_of?(String)
+          post_process( resolve_value(enum) )
+        else
+          post_process( enum.map{ |value| resolve_value(value) } )
+        end
+      end
+    end
+
+    def post_process(results)
+      #p [:post_process, results]
+      collection = create_collection
+      collection.replace(results)
+    end
+  end
+
+  # define collector methods for hash-like attribute collectors
+  class KeyedAttribute < AttributeCollector
+    #    has :init, :init => DoodleHash.new
+    has :init, :init => { }
+    #has :init, :init => OrderedHash.new
+    has :key
+
+    def post_process(results)
+      collection = create_collection
+      results.inject(collection) do |h, result|
+        h[result.send(key)] = result
+        h
+      end
+    end
+  end
+end
+
+if false
+  # not ready for primetime
+  #if RUBY_VERSION >= '1.8.7'
+  # load ruby 1.8.7+ version specific methods
+  require 'doodle/collector-1.9'
+else
+  # version for ruby 1.8.6
+  class Doodle
+
+    # define collector methods for array-like attribute collectors
+    class AppendableAttribute < AttributeCollector
+      #    has :init, :init => DoodleArray.new
+      has :init, :init => []
+
+      # define a collector for appendable collections
+      # - collection should provide a :<< method
+      def define_collector
+        collector_spec.each do |collector_name, collector_class|
+          # FIXME: don't use eval in 1.9+
+          if collector_class.nil?
+            doodle_owner.sc_eval("def #{collector_name}(*args, &block)
+                     collection = self.#{name}
+                     args.unshift(block) if block_given?
+                     collection.<<(*args);
+                   end", __FILE__, __LINE__)
+          else
+            doodle_owner.sc_eval("def #{collector_name}(*args, &block)
+                            collection = self.send(:#{name})
+                            if args.size > 0 and args.all?{|x| x.kind_of?(#{collector_class})}
+                              collection.<<(*args)
+                            else
+                              # FIXME: this is a wierd one - need name here - can't use collection directly...?
+                              #{name} << #{collector_class}.new(*args, &block)
+                              # this is OK
+                              #self.send(:#{name}) << #{collector_class}.new(*args, &block)
+                              # but this isn't
+                              #collection.<<(#{collector_class}.new(*args, &block))
+                            end
+                          end", __FILE__, __LINE__)
+          end
+        end
+      end
+    end
+
+    class KeyedAttribute
+
+      # define a collector for keyed collections
+      # - collection should provide :[], :clone and :replace methods
+      def define_collector
+        collector_spec.each do |collector_name, collector_class|
+          # need to use string eval because passing block
+          # FIXME: don't use eval in 1.9+
+          if collector_class.nil?
+            doodle_owner.sc_eval("def #{collector_name}(*args, &block)
+                     collection = #{name}
+                     args.each do |arg|
+                       #{name}[arg.send(:#{key})] = arg
+                     end
+                   end", __FILE__, __LINE__)
+          else
+            doodle_owner.sc_eval("def #{collector_name}(*args, &block)
+                            collection = #{name}
+                            if args.size > 0 and args.all?{|x| x.kind_of?(#{collector_class})}
+                              args.each do |arg|
+                                #{name}[arg.send(:#{key})] = arg
+                              end
+                            else
+                              obj = #{collector_class}.new(*args, &block)
+                              #{name}[obj.send(:#{key})] = obj
+                            end
+                       end", __FILE__, __LINE__)
+          end
+        end
+      end
+    end
+  end
+end