cascading_classes 0.1.0 → 0.2.0

data/README.md

@@ -100,17 +100,16 @@ is equivalent to
       hair_color :default => "blond"
     end
     
-or
+or 
 
     Parent.all! do
       eye_color  :initial => "blue"
       hair_color :initial => "blond"
     end
  
-#### More block examples
+### More block examples
 
 The folowing are all equivalent
-==============================
 
     Parent.cascade :address, :phone, [:email, "jon@example.com"]
 
@@ -137,44 +136,69 @@ You can also set a property in a block using ```set_property```
 
 ## Quick Summary
 
-* require the gem: ```require cascading_classes```
-* extend or include the module
+Note: CC is equivalent to CascadingClasses
+
+require the gem
+
+    require cascading_classes
+
+extend or include the module
+
     class Foo
       extend CascadingClasses
     end
-* CC is equivalent to CascadingClasses
-* create some cascading properties by listing them 
+
+create some cascading properties by listing them 
+
     A.cascade :desk, :chair, :lamp
-* or by using a block
+
+or by using a block
+
+    A.cascade do
+      desk
+      chair
+      lamp
+    end
+
+or
+
     A.cascade{ desk; chair; lamp }
-* get and set the property on any descendent
+
+get and set the property on any descendent
+
     class B < A; end
+
     B.desk = "a large, wooden structure in need of a fix"         
+
     class C < A; end
+
     C.lamp = "old and rusty"
 
-### What's the difference between ```extend CC``` and ```include CC```?
+## What's the difference between ```extend CC``` and ```include CC```?
+
+First, in either case you are dealing with class instance variables and class methods. 
 
-First, in either case you are dealing with class instance variables and class methods. ```A.cascade :eye_color; A.eye_color``` sets ```@eye_color``` on the singleton class of A.
+    A.cascade :eye_color
+    A.eye_color = "blue"
 
-But if you also want the properties to cascade down to instance variables you have three options. The first way is to ```include CC```, which will create cascading instance properties by default.
+sets ```@eye_color``` on the singleton class of ```A```.
 
-For example:
+But if you also want the properties to cascade to instance variables, you have three options. The first is to ```include CC```, which, by default, creates the properties on instances too
 
     class Parent
       include CC
     end
 
-    Parent.cascade [:eye_color, "blue"]
+    Parent.cascade [:one, 1]
     p = Parent.new
-    p p.eye_color   # => "blue"
+    p p.one   # => 1
 
     class Child < Parent; end
 
     c = Child.new
-    p c.eye_color   # => "blue"
+    p c.one   # => 1
 
-The other two ways to make properties cascade down to instances is via:
+The other two ways to ensure instances have cascaded properties is by including a third argument
 
     Parent.cascade [:hair_color, "blue", true]
 
@@ -187,4 +211,3 @@ or
 In either case, even if you ```extend CC```, all instance variables of all descendents will have the ```hair_color``` property. 
 
       
-      

data/lib/cascading_classes/cascading_classes.rb

@@ -1,163 +1,49 @@
-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 =~ /^__/ }
-  end
+require 'cascading_classes/dsl'
 
-  class Helper < CascadingClasses::BlankSlate 
-
-    def method_missing(meth, *args, &block)
-      case meth
-      when /inspect/
-        super
-      when /set_property/
-        __property__(args[0], *args[1..-1], &block)
-      else
-        __property__(meth, *args, &block)
-      end
-    end
+module CascadingClasses
 
-    def __property__(name, args={}, &block)
-      @names << name unless @names.include? name
+  def self.cascade_intern(klass, property)
+    Module.new do
 
-      @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
+      define_method property do
+        val = instance_variable_get "@#{property}"
+        return val unless (val.nil? and self != klass)
+        (self.class == Class) ? superclass.send(property) :
+          self.class.send(property)
       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                    
+      define_method "#{property}=" do |v|
+        instance_variable_set "@#{property}", v
       end
-    end
-
-    def initialize(apply_to_instances, &block)
-      @apply_to_instances = apply_to_instances
-      @names = []
-      @defaults = {} 
-      @instances_too = {}  # values are true/false
 
-      return unless block_given?
-      if block.arity == 0
-        instance_eval &block
-      else
-        raise "ArgumentError: wrong number of args for block: #{block.arity} for 1"
-      end
     end
+  end
 
-  end  # class Helper
-
-  # returns an array 
-  # apply_to_instances: whether properties should be set on instances of the classes too
-  def self.cascading_props(apply_to_instances, *properties, &block)
-    props = {}  # values are defaults
-    instances_too = {}  # values are true/false
+  # returns hash: {..., attr => [default, inst_too], .. }
+  def self.parse_options(klass, apply_to_instances, *properties, &block)
+    res = {}  
     properties.each do |prop|
-      if Array === prop and prop.size == 3
-        props[prop[0].to_sym] = prop[1]
-        instances_too[prop[0].to_sym] = !!prop[2]
-      elsif Array === prop and prop.size == 2
-        props[prop[0].to_sym] = prop[1]
-      else
-        props[prop.to_sym] = nil
+      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
+      inst_too = !!inst_too
+      res[name.to_sym] = [default, inst_too]
     end
-    
-    props.each{|prop, default| instances_too[prop] =
-      apply_to_instances unless instances_too.include? prop}
 
     if block_given?
-      a = Helper.new(apply_to_instances, &block)
+      a = CascadingClasses::DSL.new(apply_to_instances, &block)
       names, defaults, inst =
         a.instance_eval{ [@names, @defaults, @instances_too] }
-      names.each do |prop|
-        props[prop] = defaults[prop]
-        instances_too[prop] = inst[prop]
-      end
+      names.each{|name| res[name] = [defaults[name], inst[name]] }
     end
 
-    props.map do |prop, default|
-      mod = Module.new do
-
-        define_method :extended do |klass|
-          klass.class_eval{ instance_variable_set "@#{prop}", default }
-        end
-        module_function :extended
-
-        define_method :included do |klass|
-          klass.class_eval{ instance_variable_set "@#{prop}", default }
-        end
-        module_function :included
-
-        # getter has dual role as setter:
-        #   m.prop val <=> m.prop = val
-        define_method prop do |*args|
-          if args.empty?  # getter
-            val = instance_variable_get "@#{prop}"
-            if val.nil? 
-              # reach up into the class first, then into superclass
-              if self.class == Class
-                try_super = superclass.instance_eval{ respond_to? "#{prop}" }
-                return superclass.send("#{prop}") if try_super
-              else
-                try_klass_methd = self.class.send :respond_to?, prop
-                return self.class.send(prop) if try_klass_methd
-              end
-            end
-            val
-          else  # setter
-            if args.size == 1 and Array === args[0]
-              send("#{prop}=", args[0])
-            else
-              send("#{prop}=", *args)
-            end
-          end
-        end
-
-        # todo: setter validations ??
-        define_method "#{prop}=" do |*vals|
-          if vals.size == 1 and Array === vals[0]
-            vals = vals[0]
-          end
-          instance_variable_set "@#{prop}", vals[0]
-        end
-
-      end  # new module
-      [prop, props[prop], instances_too[prop], mod]
-    end
+    res
   end
 
 end  # module CascadingClasses

data/lib/cascading_classes/dsl.rb

@@ -0,0 +1,83 @@
+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 =~ /^__/ }
+  end
+
+  class DSL < BlankSlate 
+
+    def method_missing(meth, *args, &block)
+      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)
+      @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
+      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                    
+      end
+    end
+
+    def initialize(apply_to_instances, &block)
+      @apply_to_instances = apply_to_instances
+      @names = []
+      @defaults = {} 
+      @instances_too = {}  # values are true/false
+
+      return unless block_given?
+      if block.arity == 0
+        instance_eval &block
+      else
+        raise "ArgumentError: wrong number of args for block: #{block.arity} for 1"
+      end
+    end
+
+  end  # class Helper
+
+end  # module CascadingClasses

data/lib/cascading_classes.rb

@@ -11,17 +11,17 @@ CC = CascadingClasses unless defined? CC
 #   cascade :one, :two, :three, ...
 # end
 # Foo.one = 12
-# Foo.new.one
-# Bar = Class.new(Foo).one
+# Foo.new.one  # => 12
+# Bar = Class.new(Foo).one  # => 12
+# Bar.new.one  # => 12
 
 module CascadingClasses
 
-  # VERSION: "1.0.0"
   # note, VERSION will be undetected unless called directly
   def self.const_missing(name)
     case name
-    when :VERSION then "1.0.0"
-    else raise NameError
+    when :VERSION then "0.2.0"
+    else super
     end
   end
 
@@ -30,46 +30,57 @@ module CascadingClasses
   end
   module_function :respond_to?
 
-  def self.included(klass)
-    has_all = klass.instance_methods.include? :all!
-    klass.instance_eval do
-      def cascade(*props, &block)
-        res = CascadingClasses.cascading_props(true, *props, &block)
-        res.map! do |prop, default, apply_to_instances, mod|
-          send(:extend, mod)
-          send(:include, mod) if apply_to_instances
-          [prop, [default, apply_to_instances]]
+  # todo: fill in rest
+  # todo: allow one of [:cascade, :all!] to be overwritten
+  def self.illegal_names
+    [:cascade, :all!, :instance_eval, :instance_exec, :class_eval]
+  end
+
+  def self.apply(klass, instances_too)
+    klass.singleton_class.instance_eval do
+
+      define_method :cascade do |*props, &block|
+        illegal_names = CascadingClasses.illegal_names
+
+        props = CascadingClasses.parse_options(klass, instances_too, *props, &block)
+        props.each{|prop, v| raise NameError, "Illegal property name: #{prop}" if
+          illegal_names.include? prop }
+
+        props.each do |prop, v|
+          default, inst_too = v
+
+          klass.singleton_class.instance_eval do
+            undef_method prop.to_sym rescue nil
+            undef_method "#{prop}=".to_sym rescue nil
+          end
+
+          klass.instance_eval{ instance_variable_set "@#{prop}", default }
+
+          mod = CascadingClasses.cascade_intern(klass, prop)
+          klass.extend mod
+          if inst_too
+            klass.instance_eval do
+              undef_method prop.to_sym rescue nil
+              undef_method "#{prop}=".to_sym rescue nil
+            end
+            klass.send(:include, mod)
+          end
         end
-        {self.name => Hash[res]}
       end
 
-      class << klass
-        unless instance_methods.include? :all!        
-          alias_method :all!, :cascade
-        end
+      unless instance_methods.include? :all!
+        alias_method :all!, :cascade
       end
+
     end
   end
 
-  def self.extended(klass)
-    has_all = klass.instance_methods.include? :all
-    klass.instance_eval do
-      def cascade(*props, &block)
-        res = CascadingClasses.cascading_props(false, *props, &block)
-        res.map! do |prop, default, apply_to_instances, mod|
-          send(:extend, mod)
-          send(:include, mod) if apply_to_instances
-          [prop, [default, apply_to_instances]]
-        end
-        {self.name => Hash[res]}
-      end
+  def self.included(klass)
+    apply(klass, true)
+  end
 
-      class << klass
-        unless instance_methods.include? :all!        
-          alias_method :all!, :cascade
-        end
-      end
-    end
+  def self.extended(klass)
+    apply(klass, false)
   end
 
 end  # module CascadingClases

data/spec/extended_spec.rb

@@ -27,6 +27,16 @@ describe "when a class extends CascadingClasses" do
     GrandChild = Class.new(Child)
   end
 
+  describe "when a parent has a default" do
+    before do
+      Parent.cascade [:eyes, "brown"]      
+    end
+
+    it "sets the property to the default" do
+      Parent.eyes.must_equal "brown"
+    end
+  end
+
   describe "when a property is set from above" do
     before do
       Parent.cascade(:hair_color)
@@ -80,7 +90,7 @@ describe "when a class extends CascadingClasses" do
       Parent.cascade :has_house
     end
 
-    all "descendents should reflect the same" do
+    all "descendents should reflect nil" do
       Parent.has_house.must_equal nil
       Child.has_house.must_equal nil
       GrandChild.has_house.must_equal nil
@@ -102,13 +112,12 @@ describe "when a class extends CascadingClasses" do
     end
   end
 
-  describe "when a parent has a property with a default set" do
+  describe "when a parent has a property with a default" do
     before do
-      ## Parent.cascade{ :time, :default =>  32}
       Parent.cascade [:time, 32]
     end
 
-    it "won't matter if the property is first accessed by the child" do
+    it "won't matter whether the property is first accessed by the child" do
       Child.time
 
       Child.time.must_equal 32
@@ -116,7 +125,7 @@ describe "when a class extends CascadingClasses" do
     end    
   end
 
-  describe "when a parent has a property with a default set" do
+  describe "when a parent has a property with a default" do
     before do
       Parent.cascade [:time, 32]
     end
@@ -129,5 +138,30 @@ describe "when a class extends CascadingClasses" do
     end 
   end
   
-  
+  describe "when a property is set to false" do
+    before do
+      Parent.cascade [:has_time, false]
+    end
+
+    it "should return false, not nil" do
+      Parent.has_time.must_equal false
+    end
+  end
+
+  describe "when a property name is not allowed" do
+    before do
+      property = CascadingClasses.illegal_names.sample
+    end
+
+    it "should raise a NameError" do
+      res = begin
+        Parent.cascade property
+      rescue NameError
+        true
+      else
+        false
+      end
+      res.must_equal true
+    end
+  end
 end

data/spec/helper_spec.rb

@@ -0,0 +1,7 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'cascading_classes'
+require 'minitest/autorun'
+
+class << MiniTest::Spec
+  alias_method :all, :it
+end

data/spec/included_spec.rb

@@ -82,4 +82,16 @@ describe "when CascadingClasses is included by a class" do
       @c.table.must_equal nil
     end
   end
+
+  describe "when a property is set to false" do
+    before do
+      A.cascade [:has_time, false]
+    end
+
+    it "should return false, not nil" do
+      A.new.has_time.must_equal false
+    end
+  end
+
+
 end

data/spec/note.txt

@@ -0,0 +1,2 @@
+you should expect to see many "already initialized constant" warnings
+This happens because the same constants must get reloaded for every test

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cascading_classes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-03 00:00:00.000000000Z
+date: 2011-08-08 00:00:00.000000000Z
 dependencies: []
-description: 
+description: Similar to active_support/core_ext/class/attribute.rb but better. Also,
+  doesn't monkey-patch Class
 email: jeremy.gables@gmail.com
 executables: []
 extensions: []
@@ -21,9 +22,12 @@ files:
 - Rakefile
 - lib/cascading_classes.rb
 - lib/cascading_classes/cascading_classes.rb
+- lib/cascading_classes/dsl.rb
+- spec/helper_spec.rb
 - spec/extended_spec.rb
 - spec/included_spec.rb
 - spec/alternative_syntax_spec.rb
+- spec/note.txt
 homepage: http://github.com/gables/cascading_classes
 licenses: []
 post_install_message: 
@@ -49,6 +53,8 @@ signing_key:
 specification_version: 3
 summary: Easily create properties whose values cascade down class trees
 test_files:
+- spec/helper_spec.rb
 - spec/extended_spec.rb
 - spec/included_spec.rb
 - spec/alternative_syntax_spec.rb
+- spec/note.txt