doodle 0.0.1

data/lib/molic_orderedhash.rb

@@ -0,0 +1,243 @@
+# AUTHOR
+#    jan molic /mig/at/1984/dot/cz/
+#
+# DESCRIPTION
+#    Hash with preserved order and some array-like extensions
+#    Public domain. 
+#
+# THANKS
+#    Andrew Johnson for his suggestions and fixes of Hash[],
+#    merge, to_a, inspect and shift
+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
+#--}}}
+        end
+#--}}}
+    end
+#        def initialize 
+##--{{{
+#            @order = []
+##--}}}
+#        end
+    def initialize(*a, &b)
+#--{{{
+      super
+      @order = []
+#--}}}
+    end
+    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
+#--}}}
+    end
+    alias []= store
+    def == hsh2
+#--{{{
+        return false if @order != hsh2.order
+        super hsh2
+#--}}}
+    end
+    def clear
+#--{{{
+        @order = []
+        super
+#--}}}
+    end
+    def delete key
+#--{{{
+        @order.delete key
+        super
+#--}}}
+    end
+    def each_key
+#--{{{
+        @order.each { |k| yield k }
+        self
+#--}}}
+    end
+    def each_value
+#--{{{
+        @order.each { |k| yield self[k] }
+        self
+#--}}}
+    end
+    def each
+#--{{{
+        @order.each { |k| yield k,self[k] }
+        self
+#--}}}
+    end
+    alias each_pair each    
+    def delete_if
+#--{{{
+        @order.clone.each { |k| 
+            delete k if yield
+        }
+        self
+#--}}}
+    end
+    def values
+#--{{{
+        ary = []
+        @order.each { |k| ary.push self[k] }
+        ary
+#--}}}
+    end
+    def keys
+#--{{{
+        @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
+#--}}}
+    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
+#--}}}
+    end
+    def pop
+#--{{{
+        key = @order.last
+        key ? [key,delete(key)] : nil
+#--}}}
+    end
+    def to_a
+#--{{{
+        ary = []
+        each { |k,v| ary << [k,v] }
+        ary
+#--}}}
+    end
+    def 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
+#--}}}
+    end
+    alias :merge! update
+    def merge(hsh2)
+#--{{{
+        self.dup.update(hsh2)
+#--}}}
+    end
+    def select
+#--{{{
+        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
+      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(', ') << ' }'
+              }
+            }
+          class << self
+            def to_yaml opts = {}
+              begin
+                @__yaml_inline ? @__yaml_inline_meth[ opts ] : super
+              rescue
+                @to_yaml_style = :inline
+                super
+              end
+            end
+          end
+        end
+      end
+      @__yaml_inline = bool
+    end
+    def yaml_inline!() self.yaml_inline = true end
+#--}}}
+end # class OrderedHash

data/lib/spec_helper.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.join(File.dirname(__FILE__), '../.'))
+
+require 'lib/doodle'
+require 'date'
+
+def undefine_const(*consts)
+  consts.each do |const|
+    if Object.const_defined?(const)
+      Object.send(:remove_const, const)
+    end
+  end
+end
+
+def raise_if_defined(*args)
+  defined, undefined = args.partition{ |x| Object.const_defined?(x)}
+  raise "Namespace pollution: #{defined.join(', ')}" if defined.size > 0
+end
+
+

data/spec/arg_order_spec.rb

@@ -0,0 +1,125 @@
+require 'lib/spec_helper'
+
+describe 'arg_order' do
+  before :each do
+    raise_if_defined :Foo
+    class Foo < Doodle::Base
+      has :name
+      has :extra
+      has :value
+      arg_order :value, :name
+    end
+  end
+  after :each do
+    undefine_const :Foo
+  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
+  end
+
+  it 'should allow only symbols as arguments to arg_order' do
+    proc { Foo.arg_order Foo}.should raise_error(Doodle::InvalidOrderError)
+    proc { Foo.arg_order 1}.should raise_error(Doodle::InvalidOrderError)
+    proc { Foo.arg_order Date.new}.should raise_error(Doodle::InvalidOrderError)
+  end
+
+  it 'should not allow invalid positional arguments' do
+    proc { Foo.arg_order :smoo}.should raise_error(Doodle::InvalidOrderError)
+    proc { Foo.arg_order :name, :value}.should_not raise_error
+  end  
+end
+
+describe 'arg_order' do
+  before :each do
+    raise_if_defined :Foo, :Bar
+    class Foo < Doodle::Base
+      has :name
+    end
+    class Bar < Foo
+      has :value
+    end
+  end
+  after :each do
+    undefine_const(:Bar)
+    undefine_const(:Foo)
+  end
+  it 'should specify order of positional arguments' do
+    f = Bar.new 1, 2
+    f.name.should == 1
+    f.value.should == 2
+  end  
+end
+
+describe 'arg_order' do
+  before :each do
+    raise_if_defined(:Foo, :Bar)
+    class Foo < Doodle::Base
+      has :name
+    end
+    class Bar < Foo
+      has :value
+      arg_order :value, :name
+    end
+  end
+  after :each do
+    undefine_const(:Bar)
+    undefine_const(:Foo)
+  end
+  it 'should specify order of positional arguments' do
+    f = Bar.new 1, 2
+    f.value.should == 1
+    f.name.should == 2
+  end  
+
+end
+
+describe 'arg_order' do
+  before :each do
+    raise_if_defined(:Foo, :Bar)
+    class Foo < Doodle::Base
+      has :name, :default => proc { self.class.to_s.downcase }
+    end
+    class Bar < Foo
+      has :value
+      arg_order :value, :name
+    end
+  end
+  after :each do
+    undefine_const(:Bar, :Foo)
+  end
+  
+  it 'should specify order of positional arguments' do
+    f = Bar.new 1
+    f.value.should == 1
+    f.name.should == "bar"
+  end  
+
+end
+
+describe 'arg_order' do
+  after :each do
+    undefine_const(:Bar, :Foo)
+  end
+  before :each do
+    raise_if_defined(:Foo, :Bar)
+    class Foo < Doodle::Base
+      has :name
+    end
+    class Bar < Foo
+      has :value
+      arg_order :value, :name
+    end
+  end
+  
+  it 'should specify order of positional arguments' do
+    f = Bar.new 1, "bar"
+    f.value.should == 1
+    f.name.should == "bar"
+  end  
+
+end
+
+raise_if_defined(:Foo, :Bar)

data/spec/attributes_spec.rb

@@ -0,0 +1,106 @@
+require 'lib/spec_helper'
+
+describe Doodle::Attribute, 'basics' do
+  after :each do
+    undefine_const(:Bar)
+    undefine_const(:Foo)
+  end
+  before(:each) do
+    raise_if_defined(:Foo, :Bar)
+    
+    class Foo
+      include Doodle::Helper
+      has :name, :default => 'Hello'
+      class << self
+        has :metadata
+      end
+    end
+    class Bar < Foo
+      has :info
+      class << self
+        has :doc
+      end
+    end
+    
+    @goo = Foo.new
+    @baz = Bar.new :info => 'Hi'
+  end
+
+  it 'should have default name' do
+    #pending 'making it work'
+    #p [:name, :default, @goo.attributes[:name].default]
+    @goo.attributes[:name].default.should == 'Hello'
+  end
+
+  it 'should have default name' do
+    #pending 'making it work'
+    @goo.name.should == 'Hello'
+  end
+
+  it 'should have name required == false (because has default)' do
+    #pending 'to do required/optional'
+    @goo.attributes[:name].required?.should == false
+  end
+
+  it 'should have info required == true' do
+    #pending 'to do required/optional'
+    @baz.attributes[:info].required?.should == true
+  end
+
+  it 'should have name.optional? == true (because has default)' do
+    #pending 'to do required/optional'
+    @goo.attributes[:name].optional?.should == true
+  end
+
+  it 'should have info.optional? == false' do
+    #pending 'to do required/optional'
+    @baz.attributes[:info].optional?.should == false
+  end
+
+  it "should have parents in order" do
+    Bar.parents.should == [Foo, Object]
+  end
+    
+  it "should have Bar's meta parents in reverse order of definition" do
+    @baz.meta.parents.should == [Bar.singleton_class.singleton_class, Bar.singleton_class, Foo.singleton_class]
+  end
+
+  it 'should have inherited meta local_attributes in order of definition' do
+    @baz.meta.class_eval { collect_inherited(:local_attributes).map { |x| x[0]} }.should == [:metadata, :doc]
+  end
+
+  it 'should have inherited meta attributes in order of definition' do
+    @baz.meta.attributes.keys.should == [:metadata, :doc]
+  end
+end
+
+describe Doodle::Attribute, 'attribute order' do
+  before :each do
+    undefine_const(:A)
+    undefine_const(:B)
+    undefine_const(:C)
+
+    class A < Doodle::Base
+      has :a
+    end
+
+    class B < A
+      has :b
+    end
+
+    class C < B
+      has :c
+    end
+
+  end
+
+  it 'should keep order of inherited attributes' do
+    C.parents.should == [B, A, Doodle::Base, Object]
+  end
+
+  it 'should keep order of inherited attributes' do
+    C.attributes.keys.should == [:a, :b, :c]
+  end
+end
+
+raise_if_defined(:Foo, :Bar, :A, :B, :C)