doodle 0.1.3 → 0.1.4

data/lib/doodle/datatypes.rb

@@ -57,6 +57,24 @@ class Doodle
       end
     end
 
+    def boolean(name, params = { }, &block)
+      define name, params, block, { } do
+        must "be true or false" do |v|
+          [true, false].include?(v)
+        end
+        from String, Symbol do |v|
+          case v.to_s
+          when /^(yes|true|on)$/
+            true
+          when /^(no|false|off)$/
+            false
+          else
+            v
+          end
+        end
+      end
+    end
+    
     def symbol(name, params = { }, &block)
       define name, params, block, { :kind => Symbol } do
         from String do |s|
@@ -112,12 +130,7 @@ class Doodle
       # 384 = 128+1+255
       string(name, { :max => 384 }.merge(params), &block).instance_eval do
         must "be valid email address" do |s|
-          if RUBY_VERSION >= '1.9.0'
-            # the regex fails in 1.9 with illegal utf byte sequence error
-            s =~ /\A.*@.*\z/
-          else
-            s =~ RFC822::EmailAddress
-          end
+          s =~ RFC822::EmailAddress
         end
       end
     end

data/lib/doodle/rfc822.rb

@@ -12,20 +12,27 @@
 # http://creativecommons.org/licenses/by-sa/2.5/
 # 
 module RFC822
-  EmailAddress = begin
-    qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
-    dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'
-    atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-' +
-      '\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+'
-    quoted_pair = '\\x5c[\\x00-\\x7f]'
-    domain_literal = "\\x5b(?:#{dtext}|#{quoted_pair})*\\x5d"
-    quoted_string = "\\x22(?:#{qtext}|#{quoted_pair})*\\x22"
-    domain_ref = atom
-    sub_domain = "(?:#{domain_ref}|#{domain_literal})"
-    word = "(?:#{atom}|#{quoted_string})"
-    domain = "#{sub_domain}(?:\\x2e#{sub_domain})*"
-    local_part = "#{word}(?:\\x2e#{word})*"
-    addr_spec = "#{local_part}\\x40#{domain}"
-    pattern = /\A#{addr_spec}\z/
+  # TODO: fix the illegal multibyte sequence in 1.9
+  # the regex fails in 1.9 with illegal utf byte sequence error
+  if RUBY_VERSION < '1.9.0'
+    EmailAddress = begin
+                     qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
+                     dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'
+                     atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-' +
+                       '\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+'
+                     quoted_pair = '\\x5c[\\x00-\\x7f]'
+                     domain_literal = "\\x5b(?:#{dtext}|#{quoted_pair})*\\x5d"
+                     quoted_string = "\\x22(?:#{qtext}|#{quoted_pair})*\\x22"
+                     domain_ref = atom
+                     sub_domain = "(?:#{domain_ref}|#{domain_literal})"
+                     word = "(?:#{atom}|#{quoted_string})"
+                     domain = "#{sub_domain}(?:\\x2e#{sub_domain})*"
+                     local_part = "#{word}(?:\\x2e#{word})*"
+                     addr_spec = "#{local_part}\\x40#{domain}"
+                     pattern = /\A#{addr_spec}\z/
+                   end
+  else
+    # minimal regex until I sort out the problem above
+    EmailAddress = /\A.*@.*\z/
   end
 end

data/lib/doodle/version.rb

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

data/spec/arg_order_spec.rb

@@ -12,9 +12,9 @@ describe 'arg_order' do
     end
     it 'should specify order of positional arguments' do
       foo = Foo.new 1, 2, 3
-      foo.value.should == 1
-      foo.name.should == 2
-      foo.extra.should == 3
+      foo.value.should_be 1
+      foo.name.should_be 2
+      foo.extra.should_be 3
     end
 
     it 'should allow only symbols as arguments to arg_order' do
@@ -42,8 +42,8 @@ describe 'arg_order' do
     end
     it 'should specify order of positional arguments' do
       f = Bar.new 1, 2
-      f.name.should == 1
-      f.value.should == 2
+      f.name.should_be 1
+      f.value.should_be 2
     end
   end
 end
@@ -61,8 +61,8 @@ describe 'arg_order' do
     end
     it 'should specify order of positional arguments' do
       f = Bar.new 1, 2
-      f.value.should == 1
-      f.name.should == 2
+      f.value.should_be 1
+      f.name.should_be 2
     end  
   end
 end
@@ -81,8 +81,8 @@ describe 'arg_order' do
   
     it 'should specify order of positional arguments' do
       f = Bar.new 1
-      f.value.should == 1
-      f.name.should == "bar"
+      f.value.should_be 1
+      f.name.should_be "bar"
     end  
   end
 end
@@ -101,8 +101,8 @@ describe 'arg_order' do
   
     it 'should specify order of positional arguments' do
       f = Bar.new 1, "bar"
-      f.value.should == 1
-      f.name.should == "bar"
+      f.value.should_be 1
+      f.name.should_be "bar"
     end  
   end
 end

data/spec/attributes_spec.rb

@@ -64,10 +64,10 @@ describe Doodle::Attribute, 'basics' do
       @bar.attributes[:ivar2].optional?.should == false
     end
 
-    it "should have parents in correct order" do
-      expected_parents = RUBY_VERSION <= "1.8.6" ? [Foo, Object] : [Foo, Object, BasicObject]
-      Bar.parents.should == expected_parents
-    end
+#     it "should have parents in correct order" do
+#       expected_parents = RUBY_VERSION <= "1.8.6" ? [Foo, Object] : [Foo, Object, BasicObject]
+#       Bar.parents.should == expected_parents
+#     end
     
     it "should have Bar's singleton parents in reverse order of definition" do
       @bar.singleton_class.parents.should == []
@@ -128,10 +128,10 @@ describe Doodle::Attribute, 'attribute order' do
       end
     end
   
-    it 'should keep order of inherited attributes' do
-      expected_parents = RUBY_VERSION <= "1.8.6" ? [B, A, Doodle, Object] : [B, A, Doodle, Object, BasicObject]
-      C.parents.should == expected_parents
-    end
+#     it 'should keep order of inherited attributes' do
+#       expected_parents = RUBY_VERSION <= "1.8.6" ? [B, A, Doodle, Object] : [B, A, Doodle, Object, BasicObject]
+#       C.parents.should == expected_parents
+#     end
 
     it 'should keep order of inherited attributes' do
       C.attributes.keys.should == [:a, :b, :c]

data/spec/bugs_spec.rb

@@ -15,8 +15,8 @@ describe 'Doodle', 'parents' do
     
     it 'should not duplicate validations when accessing them!' do
       foo = Foo 2
-      foo.validations.size.should == 1
-      foo.validations.size.should == 1
+      foo.validations.size.should_be 1
+      foo.validations.size.should_be 1
     end
   end
 end
@@ -48,8 +48,8 @@ describe 'Doodle', ' loading good data from yaml' do
     
     it 'should apply conversions' do
       foo = YAML::load(@str).validate!
-      foo.date.should == Date.new(2000, 7, 1)
-      foo.date.class.should == Date
+      foo.date.should_be Date.new(2000, 7, 1)
+      foo.date.class.should_be Date
     end
   end
 end
@@ -124,7 +124,7 @@ 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 == %[--- !ruby/object:Person
+      yaml.should_be %[--- !ruby/object:Person
 address:
 - !ruby/object:AddressLine
   text: Henry Wood House
@@ -134,7 +134,7 @@ name: Sean
 ]
       person = YAML.load(yaml)
       proc { person.validate! }.should_not raise_error
-      person.address.all?{ |x| x.kind_of? AddressLine }.should == true
+      person.address.all?{ |x| x.kind_of? AddressLine }.should_be true
 
     end
   end
@@ -167,7 +167,7 @@ describe 'Doodle', 'hiding @__doodle__' do
     end
     it 'should not include @__doodle__ in instance_variables' do
       foo = Foo 2
-      foo.instance_variables.size.should == 1
+      foo.instance_variables.size.should_be 1
       foo.instance_variables.first.should =~ /^@var1$/
     end
     it 'should not reveal @__doodle__ in inspect string' do
@@ -176,7 +176,7 @@ describe 'Doodle', 'hiding @__doodle__' do
     end
     it 'should not include @__doodle__ in instance_variables' do
       foo = Bar 2
-      foo.instance_variables.size.should == 1
+      foo.instance_variables.size.should_be 1
       foo.instance_variables.first.should =~ /^@var2$/
     end
     it 'should correctly inspect when using included module' do
@@ -185,17 +185,17 @@ describe 'Doodle', 'hiding @__doodle__' do
     end
     it 'should correctly inspect string' do
       foo = DString("Hello")
-      foo.inspect.should == '"Hello"'
+      foo.inspect.should_be '"Hello"'
     end
     it 'should correctly inspect hash' do
       foo = DHash.new(2)
       foo[:a] = 1
-      foo.inspect.should == '{:a=>1}'
-      foo[:b].should == 2
+      foo.inspect.should_be '{:a=>1}'
+      foo[:b].should_be 2
     end
     it 'should correctly inspect array' do
       foo = DArray(3, 2)
-      foo.inspect.should == '[2, 2, 2]'
+      foo.inspect.should_be '[2, 2, 2]'
     end
   end
 end

data/spec/class_spec.rb

@@ -22,65 +22,65 @@ describe Doodle, 'class attributes' do
 
     it 'should create class attribute' do
       Foo.metadata = 'Foo metadata'
-      Foo.metadata.should == 'Foo metadata'
+      Foo.metadata.should_be 'Foo metadata'
     end
 
     it 'should access @foo class attribute via self.class' do
       @foo.class.metadata = '@foo metadata'
-      @foo.class.metadata.should == '@foo metadata'
-      Foo.metadata.should == '@foo metadata'
+      @foo.class.metadata.should_be '@foo metadata'
+      Foo.metadata.should_be '@foo metadata'
 
       Foo.metadata = 'Foo metadata'
-      Foo.metadata.should == 'Foo metadata'
-      @foo.class.metadata.should == 'Foo metadata'
+      Foo.metadata.should_be 'Foo metadata'
+      @foo.class.metadata.should_be 'Foo metadata'
     end
 
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes(false).keys.should == [:metadata]
+      Foo.singleton_class.attributes(false).keys.should_be [:metadata]
     end
   
     it "should list all class's own attributes" do
-      Foo.singleton_class.attributes.keys.should == [:metadata]
+      Foo.singleton_class.attributes.keys.should_be [:metadata]
     end
 
     it 'should create Bar class attribute' do
       Bar.metadata = 'Bar metadata'
-      Bar.metadata.should == 'Bar metadata'
+      Bar.metadata.should_be 'Bar metadata'
     end
 
     it 'should access @bar class attribute via self.class' do
       @bar.class.metadata = '@bar metadata'
-      @bar.class.metadata.should == '@bar metadata'
-      Bar.metadata.should == '@bar metadata'
+      @bar.class.metadata.should_be '@bar metadata'
+      Bar.metadata.should_be '@bar metadata'
 
       Bar.metadata = 'Bar metadata'
-      Bar.metadata.should == 'Bar metadata'
-      @bar.class.metadata.should == 'Bar metadata'
+      Bar.metadata.should_be 'Bar metadata'
+      @bar.class.metadata.should_be 'Bar metadata'
     end
 
     it 'should not allow inherited class attributes to interfere with each other' do
       Foo.metadata = 'Foo metadata'
       @bar.class.metadata = '@bar metadata'
-      @bar.class.metadata.should == '@bar metadata'
-      Bar.metadata.should == '@bar metadata'
+      @bar.class.metadata.should_be '@bar metadata'
+      Bar.metadata.should_be '@bar metadata'
 
       Bar.metadata = 'Bar metadata'
-      Bar.metadata.should == 'Bar metadata'
-      @bar.class.metadata.should == 'Bar metadata'
+      Bar.metadata.should_be 'Bar metadata'
+      @bar.class.metadata.should_be 'Bar metadata'
 
-      Foo.metadata.should == 'Foo metadata'
-      @foo.class.metadata.should == 'Foo metadata'
+      Foo.metadata.should_be 'Foo metadata'
+      @foo.class.metadata.should_be 'Foo metadata'
     end
   
     it "should list all class's own attributes" do
-      Bar.singleton_class.attributes(false).keys.should == [:doc]
+      Bar.singleton_class.attributes(false).keys.should_be [:doc]
     end
   
     it "should list all class's singleton attributes" do
-      Bar.singleton_class.attributes.keys.should == [:doc]
+      Bar.singleton_class.attributes.keys.should_be [:doc]
     end
     it "should list all class's class_attributes" do
-      Bar.class_attributes.keys.should == [:metadata, :doc]
+      Bar.class_attributes.keys.should_be [:metadata, :doc]
     end
   end
 end

data/spec/collector_spec.rb

@@ -16,11 +16,11 @@ describe Doodle, "Simple collector" do
     end
     
     it "should define a collector method :item" do
-      @foo.methods.map{ |x| x.to_sym }.include?(:item).should == true
+      @foo.methods.map{ |x| x.to_sym }.include?(:item).should_be true
     end
     
     it "should collect items into attribute :list" do
-      @foo.list.should == ["Hello", "World"]
+      @foo.list.should_be ["Hello", "World"]
     end
 
   end
@@ -37,7 +37,11 @@ describe Doodle, "Typed collector with default collector name" do
       end
       @event = Event do
         location "Stage 1"
-        location "Stage 2"
+        # todo: move this into spec
+        # should handle collected arguments with block only
+        location do
+          name "Stage 2"
+        end
       end
     end
     after :each do
@@ -45,11 +49,11 @@ describe Doodle, "Typed collector with default collector name" do
     end
     
     it "should define a collector method :location" do
-      @event.methods.map{ |x| x.to_sym }.include?(:location).should == true
+      @event.methods.map{ |x| x.to_sym }.include?(:location).should_be true
     end
     
     it "should collect items into attribute :list" do
-      @event.locations.map{|loc| loc.name}.should == ["Stage 1", "Stage 2"]
+      @event.locations.map{|loc| loc.name}.should_be ["Stage 1", "Stage 2"]
     end
 
   end
@@ -66,7 +70,7 @@ describe Doodle, "Typed collector with specified collector name" do
       end
     end
     it "should define a collector method :place" do
-      Event.instance_methods.map{ |x| x.to_sym}.include?(:place).should == true
+      Event.instance_methods.map{ |x| x.to_sym}.include?(:place).should_be true
     end
   end
 end
@@ -89,8 +93,8 @@ describe Doodle, "typed collector with specified collector name" do
           place "Stage 2"
         end
       }.should_not raise_error
-      event.locations.map{|loc| loc.name}.should == ["Stage 1", "Stage 2"]
-      event.locations.map{|loc| loc.class}.should == [Location, Location]
+      event.locations.map{|loc| loc.name}.should_be ["Stage 1", "Stage 2"]
+      event.locations.map{|loc| loc.class}.should_be [Location, Location]
     end
   end
 end
@@ -122,10 +126,82 @@ describe Doodle, "typed collector with specified collector name initialized from
       proc {
         event = Event(data)
       }.should_not raise_error
-      event.locations.map{|loc| loc.name}.should == ["Stage 1", "Stage 2"]
-      event.locations.map{|loc| loc.class}.should == [Location, Location]
-      event.locations[0].events[0].kind_of?(Event).should == true
+      event.locations.map{|loc| loc.name}.should_be ["Stage 1", "Stage 2"]
+      event.locations.map{|loc| loc.class}.should_be [Location, Location]
+      event.locations[0].events[0].kind_of?(Event).should_be true
     end
   end
 end
 
+describe Doodle, "Simple keyed collector" do
+  temporary_constant :Foo do
+    before :each do
+      class Foo < Doodle
+        has :list, :collect => :item, :key => :size
+      end
+      @foo = Foo do
+        item "Hello"
+        item "World"
+      end
+    end
+    after :each do
+      remove_ivars :foo
+    end
+    
+    it "should define a collector method :item" do
+      @foo.methods.map{ |x| x.to_sym }.include?(:item).should_be true
+    end
+    
+    it "should collect items into attribute :list" do
+      @foo.list.should_be( { 5 => "World" } )
+    end
+
+  end
+end
+
+describe Doodle, "Simple keyed collector #2" do
+  temporary_constant :Foo, :Item do
+    before :each do
+      class Item < Doodle
+        has :name
+      end
+      class Foo < Doodle
+        has :list, :collect => Item, :key => :name
+      end
+    end
+    
+    it "should define a collector method :item" do
+      foo = Foo.new
+      foo.methods.map{ |x| x.to_sym }.include?(:item).should_be true
+      foo.respond_to?(:item).should_be true
+    end
+    
+    it "should collect items into attribute :list #1" do
+      foo = Foo do
+        item "Hello"
+        item "World"
+      end
+      foo.list.to_a.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
+    end
+
+    it "should collect keyword argument enumerable into attribute :list" do
+      foo = Foo(:list =>
+                [
+                 { :name => "Hello" },
+                 { :name => "World" }
+                ]
+                )
+      foo.list.to_a.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
+    end
+    
+    it "should collect positional argument enumerable into attribute :list" do
+      foo = Foo([
+                { :name => "Hello" },
+                { :name => "World" }
+                ]
+                )
+      foo.list.to_a.map{ |k, v| [k, v.class, v.name] }.should_be( [["Hello", Item, "Hello"], ["World", Item, "World"]] )
+    end
+    
+  end
+end