doodle 0.1.8 → 0.1.9

data/lib/doodle/version.rb

@@ -2,7 +2,7 @@ class Doodle #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 8
+    TINY  = 9
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/molic_orderedhash.rb

@@ -3,227 +3,164 @@
 #
 # DESCRIPTION
 #    Hash with preserved order and some array-like extensions
-#    Public domain. 
+#    Public domain.
 #
 # THANKS
 #    Andrew Johnson for his suggestions and fixes of Hash[],
 #    merge, to_a, inspect and shift
-class OrderedHash < ::Hash
-#--{{{
+class Doodle
+  class OrderedHash < ::Hash
     attr_accessor :order
 
     class << self
-#--{{{
-        def [] *args
-#--{{{
-            hsh = OrderedHash.new
-            if Hash === args[0]
-                hsh.replace args[0]
-            elsif (args.size % 2) != 0
-                raise ArgumentError, "odd number of elements for Hash"
-            else
-                hsh[args.shift] = args.shift while args.size > 0
-            end
-            hsh
-#--}}}
+      def [](*args)
+        hsh = OrderedHash.new
+        if Hash === args[0]
+          hsh.replace args[0]
+        elsif (args.size % 2) != 0
+          raise ArgumentError, "odd number of elements for Hash"
+        else
+          hsh[args.shift] = args.shift while args.size > 0
         end
-#--}}}
+        hsh
+      end
     end
-#        def initialize 
-##--{{{
-#            @order = []
-##--}}}
-#        end
     def initialize(*a, &b)
-#--{{{
       super
       @order = []
-#--}}}
     end
-    def store_only a,b
-#--{{{
-        store a,b
-#--}}}
+    def store_only(a,b)
+      store a,b
     end
-    alias orig_store store    
-    def store a,b
-#--{{{
-        @order.push a unless has_key? a
-        super a,b
-#--}}}
+    alias orig_store store
+    def store(a,b)
+      @order.push a unless has_key? a
+      super a,b
     end
     alias []= store
-    def == hsh2
-#--{{{
-        return false if @order != hsh2.order
-        super hsh2
-#--}}}
+    def ==(hsh2)
+      return false if @order != hsh2.order
+      super hsh2
     end
     def clear
-#--{{{
-        @order = []
-        super
-#--}}}
+      @order = []
+      super
     end
-    def delete key
-#--{{{
-        @order.delete key
-        super
-#--}}}
+    def delete(key)
+      @order.delete key
+      super
     end
     def each_key
-#--{{{
-        @order.each { |k| yield k }
-        self
-#--}}}
+      @order.each { |k| yield k }
+      self
     end
     def each_value
-#--{{{
-        @order.each { |k| yield self[k] }
-        self
-#--}}}
+      @order.each { |k| yield self[k] }
+      self
     end
     def each
-#--{{{
-        @order.each { |k| yield k,self[k] }
-        self
-#--}}}
+      @order.each { |k| yield k,self[k] }
+      self
     end
-    alias each_pair each    
+    alias each_pair each
     def delete_if
-#--{{{
-        @order.clone.each { |k| 
-            delete k if yield
-        }
-        self
-#--}}}
+      @order.clone.each { |k|
+        delete k if yield
+      }
+      self
     end
     def values
-#--{{{
-        ary = []
-        @order.each { |k| ary.push self[k] }
-        ary
-#--}}}
+      ary = []
+      @order.each { |k| ary.push self[k] }
+      ary
     end
     def keys
-#--{{{
-        @order
-#--}}}
+      @order
     end
     def invert
-#--{{{
-        hsh2 = Hash.new    
-        @order.each { |k| hsh2[self[k]] = k }
-        hsh2
-#--}}}
-    end
-    def reject &block
-#--{{{
-        self.dup.delete_if(&block)
-#--}}}
-    end
-    def reject! &block
-#--{{{
-        hsh2 = reject(&block)
-        self == hsh2 ? nil : hsh2
-#--}}}
-    end
-    def replace hsh2
-#--{{{
-        @order = hsh2.keys 
-        super hsh2
-#--}}}
+      hsh2 = Hash.new
+      @order.each { |k| hsh2[self[k]] = k }
+      hsh2
+    end
+    def reject(&block)
+      self.dup.delete_if(&block)
+    end
+    def reject!(&block)
+      hsh2 = reject(&block)
+      self == hsh2 ? nil : hsh2
+    end
+    def replace(hsh2)
+      @order = hsh2.keys
+      super hsh2
     end
     def shift
-#--{{{
-        key = @order.first
-        key ? [key,delete(key)] : super
-#--}}}
-    end
-    def unshift k,v
-#--{{{
-        unless self.include? k
-            @order.unshift k
-            orig_store(k,v)
-            true
-        else
-            false
-        end
-#--}}}
-    end
-    def push k,v
-#--{{{
-        unless self.include? k
-            @order.push k
-            orig_store(k,v)
-            true
-        else
-            false
-        end
-#--}}}
+      key = @order.first
+      key ? [key,delete(key)] : super
+    end
+    def unshift(k,v)
+      unless self.include? k
+        @order.unshift k
+        orig_store(k,v)
+        true
+      else
+        false
+      end
+    end
+    def push(k,v)
+      unless self.include? k
+        @order.push k
+        orig_store(k,v)
+        true
+      else
+        false
+      end
     end
     def pop
-#--{{{
-        key = @order.last
-        key ? [key,delete(key)] : nil
-#--}}}
+      key = @order.last
+      key ? [key,delete(key)] : nil
     end
     def to_a
-#--{{{
-        ary = []
-        each { |k,v| ary << [k,v] }
-        ary
-#--}}}
+      ary = []
+      each { |k,v| ary << [k,v] }
+      ary
     end
     def to_s
-#--{{{
-        self.to_a.to_s
-#--}}}
+      self.to_a.to_s
     end
     def inspect
-#--{{{
-        ary = []
-        each {|k,v| ary << k.inspect + "=>" + v.inspect}
-        '{' + ary.join(", ") + '}'
-#--}}}
-    end
-    def update hsh2
-#--{{{
-        hsh2.each { |k,v| self[k] = v }
-        self
-#--}}}
+      ary = []
+      each {|k,v| ary << k.inspect + "=>" + v.inspect}
+      '{' + ary.join(", ") + '}'
+    end
+    def update(hsh2)
+      hsh2.each { |k,v| self[k] = v }
+      self
     end
     alias :merge! update
     def merge(hsh2)
-#--{{{
-        self.dup.update(hsh2)
-#--}}}
+      self.dup.update(hsh2)
     end
     def select
-#--{{{
-        ary = []
-        each { |k,v| ary << [k,v] if yield k,v }
-        ary
-#--}}}
+      ary = []
+      each { |k,v| ary << [k,v] if yield k,v }
+      ary
     end
     def class
-#--{{{
       Hash
-#--}}}
     end
 
     attr_accessor "to_yaml_style"
-    def yaml_inline= bool
+    def yaml_inline=(bool)
       if respond_to?("to_yaml_style")
         self.to_yaml_style = :inline
       else
         unless defined? @__yaml_inline_meth
           @__yaml_inline_meth =
             lambda {|opts|
-              YAML::quick_emit(object_id, opts) {|emitter|
-                emitter << '{ ' << map{|kv| kv.join ': '}.join(', ') << ' }'
-              }
+            YAML::quick_emit(object_id, opts) {|emitter|
+              emitter << '{ ' << map{|kv| kv.join ': '}.join(', ') << ' }'
             }
+          }
           class << self
             def to_yaml opts = {}
               begin
@@ -239,5 +176,5 @@ class OrderedHash < ::Hash
       @__yaml_inline = bool
     end
     def yaml_inline!() self.yaml_inline = true end
-#--}}}
-end # class OrderedHash
+  end # class OrderedHash
+end

data/log/debug.log

@@ -0,0 +1 @@
+

data/spec/block_init_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'yaml'
+
+describe 'Doodle', 'block initialization of scalar attributes' do
+  temporary_constant :Foo, :Bar, :Farm, :Barn, :Animal do
+    before :each do
+      class Animal < Doodle
+        has :species
+      end
+      class Barn < Doodle
+        has :animals, :collect => Animal
+      end
+      class Farm < Doodle
+        has Barn
+      end
+      class Foo < Doodle
+        has :ivar1, :kind => String
+      end
+      class Bar < Doodle
+        has :block, :kind => Proc
+      end
+    end
+    
+    it 'should initialize an scalar attribute from a block' do
+      farm = Farm do
+        barn do
+          animal "pig"
+        end
+      end
+      farm.barn.animals[0].species.should_be "pig"
+    end
+    it 'should fail trying to initialize an inappropriate attribute (not a Doodle or Proc) from a block' do
+      proc { 
+        foo = Foo do
+          ivar1 do
+            "hello"
+          end
+        end
+      }.should raise_error(ArgumentError)
+    end
+    it 'should initialize a Proc attribute from a block' do
+      bar = Bar do
+        block do
+          "hello"
+        end
+      end
+      bar.block.class.should_be Proc
+      bar.block.call.should_be "hello"
+    end
+  end
+end
+

data/spec/bugs_spec.rb

@@ -12,7 +12,7 @@ describe 'Doodle', 'inheriting validations' do
         end
       end
     end
-    
+
     it 'should not duplicate validations when accessing them!' do
       foo = Foo 2
       foo.doodle.validations.size.should_be 1
@@ -21,7 +21,7 @@ describe 'Doodle', 'inheriting validations' do
   end
 end
 
-describe 'Doodle', ' loading good data from yaml' do
+describe 'Doodle', 'loading good data from yaml' do
   temporary_constant :Foo do
     before :each do
       class Foo < Doodle
@@ -30,12 +30,12 @@ describe 'Doodle', ' loading good data from yaml' do
             Date.parse(s)
           end
         end
-      end      
+      end
       @str = %[
       --- !ruby/object:Foo
       date: "2000-7-01"
       ]
-      
+
     end
 
     it 'should succeed without validation' do
@@ -45,7 +45,7 @@ describe 'Doodle', ' loading good data from yaml' do
     it 'should validate ok' do
       proc { foo = YAML::load(@str).validate! }.should_not raise_error
     end
-    
+
     it 'should apply conversions' do
       foo = YAML::load(@str).validate!
       foo.date.should_be Date.new(2000, 7, 1)
@@ -54,7 +54,7 @@ describe 'Doodle', ' loading good data from yaml' do
   end
 end
 
-describe 'Doodle', ' loading bad data from yaml' do
+describe 'Doodle', 'loading bad data from yaml' do
   temporary_constant :Foo do
     before :each do
       class Foo < Doodle
@@ -67,7 +67,7 @@ describe 'Doodle', ' loading bad data from yaml' do
       @str = %[
       --- !ruby/object:Foo
       date: "2000"
-      ]      
+      ]
     end
 
     it 'should succeed without validation' do
@@ -94,7 +94,7 @@ describe 'Doodle', 'loading bad data from yaml with default defined' do
       @str = %[
       --- !ruby/object:Foo
       date: "2000"
-      ]      
+      ]
     end
 
     it 'should succeed without validation' do
@@ -141,7 +141,7 @@ describe Doodle, 'initializing from hashes and yaml' do
 
       yaml = %[
 ---
-:address: 
+:address:
 - Henry Wood House
 - London
 :name: Sean
@@ -151,14 +151,16 @@ describe Doodle, 'initializing from hashes and yaml' do
       yaml = person.to_yaml
       # be careful here - Ruby yaml is finicky (spaces after class names)
       yaml = yaml.gsub(/\s*\n/m, "\n")
-      yaml.should_be %[--- !ruby/object:Person
-address:
-- !ruby/object:AddressLine
-  text: Henry Wood House
-- !ruby/object:AddressLine
-  text: London
-name: Sean
-]
+#       yaml.should_be %[--- !ruby/object:Person
+# address:
+# - !ruby/object:AddressLine
+#   text: Henry Wood House
+# - !ruby/object:AddressLine
+#   text: London
+# name: Sean
+# ]
+
+      yaml.should_be "--- !ruby/object:Person\naddress:\n- !ruby/object:AddressLine\n  text: Henry Wood House\n- !ruby/object:AddressLine\n  text: London\nname: Sean\n"
       person = YAML.load(yaml)
       proc { person.validate! }.should_not raise_error
       person.address.all?{ |x| x.kind_of? AddressLine }.should_be true
@@ -187,7 +189,7 @@ describe 'Doodle', 'hiding @__doodle__' do
         include Doodle::Core
       end
     end
-    
+
     it 'should not reveal @__doodle__ in inspect string' do
       foo = Foo 2
       foo.inspect.should_not =~ /@__doodle__/
@@ -226,3 +228,97 @@ describe 'Doodle', 'hiding @__doodle__' do
     end
   end
 end
+
+describe 'Doodle', 'initalizing class level collectors' do
+  temporary_constant :Menu, :KeyedMenu, :Item, :SubMenu do
+    before :each do
+      class Item < Doodle
+        has :title
+      end
+      class Menu < Doodle
+        class << self
+          has :items, :collect => Item
+        end
+      end
+      class KeyedMenu < Doodle
+        class << self
+          has :items, :collect => Item, :key => :title
+        end
+      end
+    end
+
+    it 'should collect first item specified in appendable collector' do
+      class SubMenu < Menu
+        item "Item 1"
+      end
+      SubMenu.items[0].title.should_be "Item 1"
+    end
+
+    it 'should collect all items specified in appendable collector' do
+      class SubMenu < Menu
+        item "New Item 1"
+        item "New Item 2"
+        item "New Item 3"
+      end
+      SubMenu.items[0].title.should_be "New Item 1"
+      SubMenu.items[2].title.should_be "New Item 3"
+      SubMenu.items.size.should_be 3
+    end
+
+    it 'should collect first item specified in keyed collector' do
+      class SubMenu < KeyedMenu
+        item "Item 1"
+      end
+      SubMenu.items["Item 1"].title.should_be "Item 1"
+    end
+
+    it 'should collect all items specified in keyed collector' do
+      class SubMenu < KeyedMenu
+        item "New Item 1"
+        item "New Item 2"
+        item "New Item 3"
+      end
+      SubMenu.items["New Item 1"].title.should_be "New Item 1"
+      SubMenu.items["New Item 3"].title.should_be "New Item 3"
+      SubMenu.items.size.should_be 3
+    end
+
+    it 'should collect all items specified in keyed collector in order' do
+      class SubMenu < KeyedMenu
+        item "New Item 1"
+        item "New Item 2"
+        item "New Item 3"
+      end
+      SubMenu.items.to_a[0][0].should_be "New Item 1"
+      SubMenu.items.to_a[2][0].should_be "New Item 3"
+      SubMenu.items.size.should_be 3
+    end
+  end
+end
+
+describe 'Doodle', 'validating required attributes after default attributes' do
+  temporary_constant :Foo do
+    before :each do
+      class Foo < Doodle
+        has :v1, :default => 1
+        has :v2
+      end
+    end
+
+    it 'should validate required attribute after an attribute with default defined' do
+      proc { Foo.new }.should raise_error(Doodle::ValidationError)
+    end
+
+    it 'should validate required attribute after an attribute with default defined specified #1' do
+      proc { Foo.new(1) }.should raise_error(Doodle::ValidationError)
+    end
+
+    it 'should validate required attribute after an attribute with default defined specified #2' do
+      proc { Foo.new(:v1 => 1) }.should raise_error(Doodle::ValidationError)
+    end
+
+    it 'should validate specified required attribute after an attribute with default defined not specified' do
+      proc { Foo.new(:v2 => 2) }.should_not raise_error
+    end
+  end
+end