cascading_classes 0.3.0 → 0.6.0

data/lib/cascading_classes/dsl.rb

@@ -1,94 +1,147 @@
+
+# todo: blocks in each property definition??
+
 module CascadingClasses
 
-  # based off 
-  # http://blog.oleganza.com/post/115377756/correct-blankslate-in-ruby
   class BlankSlate 
     class << self; alias __undef_method undef_method; end
     keep = [:instance_eval, :object_id]
-    ancestors.inject([]){|res, a| res + (a.instance_methods - keep)}.uniq.
-      each{|m| (__undef_method(m) rescue nil) unless m =~ /^__/ }
+    ancestors.inject([]){|res, a|
+      res + (a.instance_methods - keep)
+    }.uniq.each{|m|
+      (__undef_method(m) rescue nil) unless m =~ /^__/
+    }
   end
-
+  
   class DSL < BlankSlate 
 
+    ## def method_missing(meth, *args, &block)
     def method_missing(meth, *args, &block)
+      ## args.unshift(Hash.new) if block_given?   # hackish: turns empty block into a hash
       case meth
       when /inspect/
         super
-      when /set_property/
-        __property__(args[0], *args[1..-1], &block)
       else
         __property__(meth, *args, &block)
       end
     end
 
     def __property__(name, args={}, &block)
+      name = name.to_sym
+
       @names << name unless @names.include? name
 
-      @defaults[name] = if args.include? :default
-        args[:default]
-      elsif args.include? :initial
-        args[:initial]
-      elsif args.include? :start
-        args[:start]
-      elsif args.include? :begin
-        args[:begin]
-      else
-        nil
+      args.keys.each{|k| args[k.to_sym] = args.delete(k) unless Symbol === k}
+
+      t = [:default, :start, :begin, :data, :template].detect{|v| args.include?(v)}
+      ## t = [:default].detect{|v| args.include?(v)}
+      if t
+        @default[name] = args[t]
+        ## (@options_given[name] ||= []) << :default
       end
 
-      @instances_too[name] = if args.include? :classes_only
-        !args[:classes_only]
-      elsif args.include? :only_classes
-        !args[:only_classes]
-      elsif args.include? :classes_only
-        !args[:classes_only] 
-      elsif args.include? :exclude_instances
-        !args[:exclude_instances]
-      elsif args.include? :skip_instances
-        !args[:skip_instances]
-      elsif args.include? :not_instances
-        !args[:not_instances]
-      elsif args.include? :apply_to_instances
-        args[:apply_to_instances]
-      elsif args.include? :both
-        args[:both]
-      elsif args.include? :instances_too
-        args[:instances_too]
-      elsif args.include? :instances
-        args[:instances]
-      elsif args.include? :instance
-        args[:instance]
-      else
-        @apply_to_instances                    
+      t = [:classes_only, :only_classes, :exclude_instances, :no_instances,
+           :not_instances, :skip_instances].detect{|v| args.include?(v)}
+      s = [:instances, :apply_to_instances, :both, :classes_and_instances,
+           :instances_and_classes, :instances_too, :instance].detect{|v| args.include?(v)}
+      @instances_too[name] = nil
+      @instances_too[name] = !args[t] if t
+      @instances_too[name] = !!args[s] if s
+      @instances_too[name] = @apply_to_instances unless t or s
+
+      t = [:getter, :getters, :reader, :readers].detect{|v| args.include?(v)}
+      @getters[name] = t ? [*args[t]] : [name]
+
+      t = [:setter, :setters, :writer, :writers].detect{|v| args.include?(v)}
+      @setters[name] = t ? [*args[t]] : ["#{name}=".to_sym]
+
+      # nil or a after callback
+      t = [:after_get, :after_getter, :after_read, :after_reader,
+           :after, :after_callback, :callback].detect{|v| args[v]}
+      @after_get[name] = t ? args[t] : nil
+      ## @after_get[name] = block if block # and t.nil?
+      # NOTE: the line above doesn't work when default == {}
+      #   since it assumes there is a block
+
+      @type_raw[name] =
+        if t = [:bool, :boolean, :binary, :FalseClass,
+                :TrueClass].detect{|v| args.include?(v)}
+          [:TrueClass, args[t]]
+        elsif t = [:int, :integer, :fixnum, :Fixnum,
+                   Fixnum].detect{|v| args.include?(v)}
+          [:Fixnum, args[t]]
+        elsif t = [:float, :Float, Float].detect{|v| args.include?(v)}
+          [:Float, args[t]]
+        elsif t = [:string, :str, :String, String].detect{|v| args.include?(v)}
+          [:String, args[t]]
+        elsif t = [:dict, :hash, :Hash, Hash].detect{|v| args.include?(v)}
+          [:Hash,  args[t]]
+        elsif t = [:array, :list, :Array, Array].detect{|v| args.include?(v)}
+          [:Array, args[t]]
+        elsif t = [:set, :Set, Set].detect{|v| args.include?(v)}
+          [:Set, args[t]]
+        elsif t = [:proc, :Proc, Proc].detect{|v| args.include?(v)}
+          [:Proc, args[t]]
+        ## elsif t = [:nil, :NilClass, NilClass].detect{|v| args.include?(v)}
+          ## [:NilClass, args[t]]
+        elsif t = [:sym, :symbol, :Symbol, Symbol].detect{|v| args.include?(v)}
+          [:Symbol, args[t]]
+        else
+          args.include?(:type) ? [args[:type].to_s.to_sym, true] : [nil, nil]
+        end
+
+      if t = [:blank, :null].detect{|v| args.include?(v)}
+        @blank[name] = if Proc === args[t]
+          args[t]
+        else
+          blank_val = args[t]
+          Proc.new{|v| v == blank_val}
+        end
+        (@options_given[name] ||= []) << :blank
       end
 
-      @getters[name] = if args.include? :getter
-        [*args[:getter]]
-      elsif args.include? :getters
-        [*args[:getters]]
-      elsif args.include? :get
-        [*args[:get]]
-      else
-        [name.to_sym]
+      t = [:proc_inst_exec, :proc_instance_exec].detect{|v| args.include?(v)}
+      @proc_inst_exec[name] = t ? !!args[t] : CascadingClasses.proc_inst_exec?
+
+      t = [:block_inst_exec, :block_instance_exec].detect{|v| args.include?(v)}
+      @block_inst_exec[name] = t ? !!args[t] : CascadingClasses.block_inst_exec?
+
+      t = [:new, :new_instance, :init, :initialize].detect{|v| args.include?(v)}
+      if t
+        raise "#{args[t]} is not of type Proc (for #{t})" unless Proc === args[t]
+        @new[name] = args[t]
+        (@options_given[name] ||= []) << :new
+      end
+        
+      t = [:ensure_type].detect{|v| args.include?(v)}
+      if t
+        raise "#{args[t]} is not of type Proc (for #{t})" unless Proc === args[t]
+        @ensure_type[name] = args[t]
+        (@options_given[name] ||= []) << :ensure_type
       end
 
-      @setters[name] = if args.include? :setter
-        [*args[:setter]]
-      elsif args.include? :setters
-        [*args[:setters]]
-      elsif args.include? :set
-        [*args[:set]]
-      else
-        ["#{name}=".to_sym]
+      t = [:inherit, :inherit_mode].detect{|v| args.include?(v)}
+      if t
+        unless s = [nil, false, true].any?{|v| args[t] == v}
+          raise "':inherit' value: #{args[t]} must be one of: nil, false, true, <fixnum>" unless
+            Fixnum === args[t]
+        end
+        @inherit[name] = args[t]
+        (@options_given[name] ||= []) << :inherit
       end
     end
 
     def initialize(apply_to_instances, &block)
-      @apply_to_instances = apply_to_instances
+      @type_raw = {}  # temp var
+      @apply_to_instances = !!apply_to_instances
       @names = []
-      @defaults, @instances_too = {}, {}
+      @default, @instances_too = {}, {}
       @getters, @setters = {}, {}
+      @type, @after_get = {}, {}
+      @blank, @proc_inst_exec, @block_inst_exec = {}, {}, {}
+      @new, @inherit = {}, {}
+      @ensure_type = {}
+      @options_given = {}  # need to know which options were set manually
 
       return unless block_given?
       if block.arity == 0
@@ -96,6 +149,31 @@ module CascadingClasses
       else
         raise "ArgumentError: wrong number of args for block: #{block.arity} for 1"
       end
+
+      @names.each do |name|
+        type = @type[name] = CascadingClasses.get_type(@default[name], *@type_raw[name])
+
+        @blank[name] = CascadingClasses.default_blank(type) unless @blank[name]
+        @new[name] = CascadingClasses.default_new(type) unless @new[name]  
+
+        unless CascadingClasses.undefined_type?(type)
+          ## unless @default.include?(name) and not @default[name].nil?
+          unless @default.include?(name)
+            @default[name] = @new[name].call
+          end
+        end
+
+        unless @inherit.include?(name)
+          @inherit[name] = CascadingClasses.undefined_type?(type) ? :undef :
+            (CascadingClasses.is_container?(type) ? false : true)
+        end
+
+        @ensure_type[name] =
+          CascadingClasses.default_ensure_type(type, @blank[name], @new[name]) unless
+            @ensure_type.include?(name)
+
+        @options_given[name] ||= []
+      end
     end
 
   end  # class Helper

data/lib/cascading_classes/parse_options.rb

@@ -0,0 +1,71 @@
+require 'cascading_classes/dsl'
+
+module CascadingClasses
+
+  # returns hash: {..., attr => [default, inst_too], .. }
+  # todo: consider removing support for custom getters/setters in array syntax
+  def self.parse_options(apply_to_instances, *properties, &block)
+    err = "syntax error: list properties or supply block, but not both" 
+    raise err if properties.size > 0 and block_given?
+
+    res = {}
+    properties.each do |prop|
+      name, default, inst_too = prop, nil, apply_to_instances
+      if Array === prop 
+        case prop.size
+        when 0 then next
+        when 1 then name = prop[0]
+        when 2 then name, default = prop[0..1]
+        else
+          name, default, inst_too = prop[0..2]
+        end
+      end
+      name = name.to_sym
+      ## type = default.nil? ? :Object : default.class.name.to_sym
+      type = default.nil? ? CascadingClasses.undefined_type() : default.class.name.to_sym
+
+      new_proc = CascadingClasses.default_new(type)    # proc creates new obj
+      is_blank = CascadingClasses.default_blank(type)  # proc verifies blank values
+
+      res[name] = {
+        :default => default, :inst_too => !!inst_too,
+        :getters => [name], :setters => ["#{name}=".to_sym],
+        :type => type, :after_get => nil,
+        :blank => is_blank,
+        :proc_inst_exec => CascadingClasses.proc_inst_exec?,
+        :block_inst_exec => CascadingClasses.block_inst_exec?,
+        :new => new_proc,
+        :inherit => CascadingClasses.undefined_type?(type) ?
+          :undef : (CascadingClasses.is_container?(type) ? false : true),
+        :ensure_type => CascadingClasses.default_ensure_type(type, is_blank, new_proc),
+        :options_given => []
+      }
+    end
+
+    if block_given?
+      a = CascadingClasses::DSL.new(apply_to_instances, &block)
+
+      names = a.instance_eval{ @names }
+
+      pluck = proc{|v| a.instance_eval("@#{v}") }
+
+      vars = [:default, :instances_too, :getters, :setters, :type, :after_get, :blank,
+              :proc_inst_exec, :block_inst_exec, :new, :inherit, :ensure_type, 
+              :options_given]
+
+      names.each{|name| res[name] = Hash[ vars.map{|v| [v, pluck.call(v)[name]] } ] }
+    end
+
+    # validation
+    res.each do |name, settings|
+
+=begin  -> why must new values be blank? ans: b/c if they don't
+      new_var = settings[:new].call
+      raise "proc to create new #{settings[:type]} is #{new_var.inspect}, not blank" unless
+        settings[:blank].call(new_var)
+=end
+    end
+
+    res
+  end
+end

data/lib/cascading_classes/types.rb

@@ -0,0 +1,229 @@
+module CascadingClasses
+  def self.undefined_type
+    :undefined_type
+  end
+
+  def self.undefined_type?(type)
+    type == self.undefined_type
+  end
+
+  def self.basic_types
+    [:String, :Fixnum, :Float, :bool, :boolean, :Symbol, :Hash, :Array,
+     :Set, :Proc, :FalseClass, :TrueClass]
+  end
+
+  # turns :Hash into Hash, :Array into Array, ...
+  def self.unsymbolize(obj)
+    res = eval(obj.to_s) rescue nil
+    (res.class == Class) ? res : obj
+  end
+
+  # typically you will be given just a default value, from that
+  #   we need to determine the type: default.class.to_s.to_sym
+  #   in this case ensure_type will be nil and ensure_val will be ignored
+  #
+  # but a type can also be specified explicitly:
+  #
+  #   A.cascade do
+  #     name :hash => true
+  #   end
+  #
+  # in this case ensure_type will be :Hash and ensure_val will be true
+  def self.get_type(default=nil, ensure_type=nil, ensure_val=nil)
+    raise "type: #{ensure_type} must be set to true or false, not #{ensure_val}" unless
+      ensure_val == true or ensure_val == false if ensure_type
+
+    type = default.class.to_s.to_sym
+    type = self.undefined_type if type == :NilClass
+
+    if ensure_type
+      if ensure_val then ensure_type
+      ## elsif ensure_type == type then :Object
+      elsif ensure_type == type then self.undefined_type
+      else type
+      end
+    else type
+    end
+  end
+
+  def self.is_of_type?(obj, klass)
+    obj.class.to_s.to_sym == klass
+  end
+
+  # returns a proc that takes an argument, evaluating
+  #   whether it is blank
+  def self.default_blank(klass)
+    ## raise "Hell" unless basic_type.include klass  # sanity
+
+=begin
+    if is_container?(klass)
+      return Proc.new{|v| v.respond_to?(:size) ? v.size.zero? : true}  # *eval*
+    end
+=end
+    return Proc.new{|v| v.size.zero?} if is_container?(klass)  # *eval*
+
+    klass = klass.to_s.to_sym
+
+    case klass
+    ## when :Proc, :Object then Proc.new{|v| v.nil? }
+    when :Proc then Proc.new{|v| v.nil? }
+    when :String then Proc.new{|v| v == ''}
+    when :Fixnum, :Float then Proc.new{|v| v.nil?}
+      ## Proc.new{|v| v.zero? }
+    when :Symbol then Proc.new{|v| v.nil? or v.size.zero? }
+    when :FalseClass, :TrueClass then Proc.new{|v| v.nil? }
+    else
+      self.undefined_type?(klass) ? Proc.new{|v| v.nil? } :
+        Proc.new{|v| !!v}
+    end
+  end
+
+  # subclass' initialition of own version of property 
+  def self.default_new(klass)
+    ## raise "Hell" unless basic_type.include klass  # sanity
+    case klass
+    when :String then Proc.new{ String.new }
+    when :Fixnum then Proc.new{ nil }
+      ## Proc.new{ 0 }
+    when :Float then Proc.new{ nil }
+      ## Proc.new{ 0.0 }
+    when :Hash then Proc.new{ Hash.new }
+    when :Array then Proc.new{ Array.new }
+    when :Proc, :Symbol then Proc.new{ nil }
+    when :FalseClass, :TrueClass, :NilClass then Proc.new{ nil }
+    else
+      if self.undefined_type?(klass) then Proc.new{ nil }
+      else
+        s = (klass.class == Class) ? klass : unsymbolize(klass)  # *eval*
+        if s.class == Class and s.respond_to?(:new)
+          Proc.new{ s.new }
+        else
+          raise "don't know how to create new instance for #{klass}"
+        end
+      end
+    end
+  end
+
+  # naive transformation to be applied for each type to ensure
+  #   that it stays that type
+  # of course it would be better (wouldn't it??) to react
+  #   to an object rather than a 'type'
+  #   but one of the features we support is to specify the
+  #   type before any default data has been given 
+  # procs take any value and should attempt to convert to specified type
+  # is_blank: proc that determines whether a value of that type is blank
+  # new_proc: proc that creates new objects of that type
+  def self.default_ensure_type(klass, is_blank, new_proc)
+    ## raise "Hell" unless basic_type.include klass  # sanity
+    klass = klass.to_s.to_sym
+    pre = lambda{|v|
+      is_blank.call(v) ? v : (v || new_proc.call) }
+
+    case klass
+    when :Hash
+      lambda do |v|
+        return v if is_blank.call(v)
+        v = new_proc.call if v.nil?
+        return v if CascadingClasses.is_of_type?(v, klass)
+        v = v.to_hash if v.respond_to?(:to_hash)
+        Hash === v ? v : {v => nil}
+      end
+    when :Array
+      lambda do |v|
+        return v if is_blank.call(v)
+        v = new_proc.call if v.nil?
+        return v if CascadingClasses.is_of_type?(v, klass)
+        v = v.to_a if v.respond_to?(:to_a)
+        Array === v ? v : [*v]
+      end
+    when :Set
+      lambda do |v|
+        return v if is_blank.call(v)
+        v = new_proc.call if v.nil?
+        return v if CascadingClasses.is_of_type?(v, klass)
+        if v.respond_to? :to_set
+          v.to_set
+        elsif v.respond_to? :to_a
+          Set.new(v.to_a)
+        else
+          Set.new([*v])
+        end
+      end
+    ## when :Proc then Proc.new{|v| v}
+    when :Proc
+      Proc.new do |v|
+        if v.nil? then nil
+        elsif Proc === v then v
+        else Proc.new{ v }
+        end
+      end
+    when :Fixnum
+      lambda{|v|
+        return v if is_blank.call(v)
+        v.to_i
+      }
+    when :Float
+      lambda{|v|
+        return v if is_blank.call(v)
+        v.to_f
+      }
+    when :String
+      lambda{|v|
+        return v if is_blank.call(v)
+        v.to_s
+      }
+    when :Symbol
+      lambda{|v|
+        return v if is_blank.call(v)
+        v.respond_to?(:to_sym) ? v.to_sym : "#{v}".to_sym
+      }
+    when :FalseClass, :TrueClass
+      lambda{|v|
+        return v if is_blank.call(v)
+        v.nil? ? nil : !!(v)
+      }
+    when :NilClass then Proc.new{|v| nil}
+    ## when :Object then Proc.new{|v| v}   # unknown type
+      ## Proc.new{|v| raise "hell"}  # sanity
+    else
+      if self.undefined_type?(klass) then Proc.new{|v| v}
+      else
+        lambda do |v|
+          return v if is_blank.call(v)
+          v = new_proc.call if v.nil?
+          return v if CascadingClasses.is_of_type?(v, klass) 
+          raise "error: don't know how to convert #{v} to object of type #{klass}"
+        end
+      end
+    end
+  end
+
+  def self.is_container?(obj, blk=nil)
+    obj = unsymbolize(obj) if Symbol === obj
+    return blk.call(obj) if blk
+    s = (obj.class == Class) ? obj : obj.class
+    s.ancestors.include?(Enumerable) or
+      s.instance_methods.include?(:each)
+  end
+
+  def self.is_hash_like?(obj, blk=nil)
+    obj = unsymbolize(obj) if Symbol === obj
+    return blk.call(obj) if blk
+    s = (obj.class == Class) ? obj : obj.class
+    return true if s.ancestors.include?(Hash)
+    meths = s.instance_methods
+    meths.include?(:keys) and meths.include?(:include?) and
+      (meths.include?(:[]) or meths.include?(:fetch))
+  end
+
+  def self.is_array_like?(obj, blk=nil)
+    obj = unsymbolize(obj) if Symbol === obj
+    return blk.call(obj) if blk
+    s = (obj.class == Class) ? obj : obj.class
+    return true if s.ancestors.include?(Array)
+    meths = s.instance_methods
+    meths.include?(:index) and meths.include?(:at) and
+      meths.include?(:include?)
+  end
+
+end