dao 5.0.0 → 5.1.1

data/dao.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification::new do |spec|
   spec.name = "dao"
-  spec.version = "5.0.0"
+  spec.version = "5.1.1"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "dao"
   spec.description = "description: dao kicks the ass"

data/lib/dao.rb

@@ -11,7 +11,7 @@
 # dao libs
 #
   module Dao
-    Version = '5.0.0' unless defined?(Version)
+    Version = '5.1.1' unless defined?(Version)
 
     def version
       Dao::Version

data/lib/dao/form.rb

@@ -358,6 +358,10 @@ module Dao
         values = attributes.get(*key) if attributes.has?(*key)
       end
 
+      if options[:multiple]
+        name += '[]'
+      end
+
       list = Array(values).map{|value| value.dup rescue value} # ensure list is dup'd
 
       case list.first
@@ -384,9 +388,15 @@ module Dao
         if options.has_key?(:selected)
           options.delete(:selected)
         else
-          value_for(attributes, keys)
+          attributes.get(keys)
         end
 
+      selected_values = {}
+
+      Array(selected_value).flatten.compact.each do |val|
+        selected_values[val.to_s] = true
+      end
+
       select_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){
         if blank
           content = blank.first || ''
@@ -423,7 +433,7 @@ module Dao
             end
 
             if selected.nil?
-              selected = (value.to_s == selected_value.to_s)
+              selected = selected_values.has_key?(value.to_s)
             end
 
             opts[:value] = (value.nil? ? content : value)

data/lib/dao/mode.rb

@@ -39,29 +39,36 @@ module Dao
 
   # instance methods
   #
-    def cases
-      @cases ||= []
+    def aliases
+      @aliases ||= []
+    end
+
+    def Mode.alias(a, b)
+      a, b = Mode.for(a), Mode.for(b)
+      a.aliases.push(b) unless a.aliases.include?(b)
+      b.aliases.push(a) unless b.aliases.include?(a)
+      (a.aliases + b.aliases).uniq
     end
 
     def case_of?(other)
-      self == other or other.cases.include?(self)
+      a, b = self, Mode.for(other)
+      a == b or a.aliases.include?(b) or b.aliases.include?(a)
     end
 
     def ===(other)
       case_of?(other)
     end
 
-    Read = %w( options get head )
-    Write = %w( post put delete trace connect )
-    Http = Read + Write
-    Http.each do |verb|
-      Mode.add(verb)
-    end
+  # setup mode singletons and their aliases
+  #
+    HTTP = ( READ = %w[ get options head ] ) + ( WRITE = %w[ post put delete trace connect ] )
 
     Mode.add(:read)
-    Read.each{|m| Mode.read.cases.push(Mode.send(m))}
-
     Mode.add(:write)
-    Write.each{|m| Mode.write.cases.push(Mode.send(m))}
+
+    HTTP.each{|verb| Mode.add(verb)}
+
+    Mode.alias(:read, :get)
+    Mode.alias(:write, :post)
   end
 end

data/lib/dao/rails/lib/generators/dao/dao_generator.rb

@@ -12,6 +12,9 @@ class DaoGenerator < Rails::Generators::NamedBase
       when /system/
         generate_system!
 
+      when /helper/
+        generate_helper!
+
       when /api/
         generate_system!
 
@@ -30,6 +33,10 @@ protected
     template "conducer.rb", "app/conducers/#{ @conducer_name.underscore }.rb"
   end
 
+  def generate_helper!
+    copy_file("dao_helper.rb", "app/helpers/dao_helper.rb")
+  end
+
   def generate_system!
     FileUtils.mkdir_p(File.join(Rails.root, 'app/conducers'))
 

data/lib/dao/rails/lib/generators/dao/templates/dao_helper.rb

@@ -1,17 +1,12 @@
 # -*- encoding : utf-8 -*-
 module DaoHelper
   def dao_form_for(*args, &block)
+  # grok the model, or build one on the fly
+  #
     model = args.flatten.select{|arg| arg.respond_to?(:persisted?)}.last
 
     options = args.extract_options!.to_options!
 
-    options[:builder] = Dao::Form::Builder
-
-    if options[:post] or model.blank?
-      options[:url] ||= (options.delete(:post) || request.fullpath)
-      options[:method] ||= :post
-    end
-
     args.push(options)
 
     if model.blank?
@@ -20,22 +15,55 @@ module DaoHelper
       args.unshift(model)
     end
 
+  # build urls to *relative to the current controller* (with respect to the
+  # resource's state) unless specified...
+  #
+    html = dao_form_attrs(options.delete(:html) || {})
+
+    if model
+      url = options.delete(:url)
+      method = options.delete(:method) || html.delete(:method)
+
+      if model.persisted?
+        method ||= :put
+      else
+        method ||= :post
+      end
+
+      url ||=
+        case method
+          when /post/
+            url_for(:action => :create)
+          when /put/
+            url_for(:action => :update)
+          else
+            './'
+        end
+
+      options[:url] = url
+      options[:html] = html.merge(:method => method)
+    end
+
+  # use a dao form builder...
+  #
+    options[:builder] = Dao::Form::Builder
+
+  # delegate the rest of th magick to rails...
+  #
     form_for(*args, &block)
   end
   alias_method(:dao_form, :dao_form_for)
 
   def dao_form_attrs(*args)
     args.flatten!
+
     options = args.extract_options!.to_options!.dup
-    options[:class] ||= []
-    options[:class] = Array(options[:class])
-    options[:class].push('dao')
-    options[:class].push(args.map{|arg| arg.to_s})
-    options[:class].flatten!
-    options[:class].compact!
-    options[:class].uniq!
-    options[:class] = options[:class].join(' ')
+
+    options[:class] =
+      [args, options.delete(:class)].join(' ').scan(%r/[^\s]+/).push(' dao ').uniq.join(' ')
+
     options[:enctype] ||= "multipart/form-data"
+
     options
   end
 
@@ -69,7 +97,7 @@ module DaoHelper
     @dao.route = request.fullpath
 
     unless options[:error!] == false
-      @dao.error! unless(@dao.status =~ or @dao.status == 420)
+      @dao.error! unless(@dao.status =~ 200 or @dao.status == 420)
     end
 
     block ? block.call(@dao) : @dao

data/test/api_test.rb

@@ -48,88 +48,102 @@ Testing Dao do
   end
 
   testing 'that an api can be called with different modes' do
-    api_class =
-      assert{
-        Dao.api do
-          call(:foo) do
-            data.modes = []
-
-            Dao::Mode.list.each do |mode|
-              send(mode){ data.modes.push(mode) }
+    Dao::Mode.list.each do |mode|
+      api_class =
+        assert{
+          Dao.api do
+            call(:foo) do
+              send(mode){ data.update(:mode => mode) }
             end
           end
-        end
-      }
-    api = assert{ api_class.new }
+        }
+      api = assert{ api_class.new }
 
-    Dao::Mode.list.each do |mode|
-      result = api.mode(mode).call(:foo)
-      assert{ result.data.modes.include?(mode) }
+      assert{ api.mode(mode).call(:foo).data[:mode] == mode }
     end
   end
 
-  testing 'that options/head/get are considered read modes' do
-    read_mode = assert{ Dao::Mode.read }
-
+  testing 'that read==get' do
     api_class =
       assert{
         Dao.api do
           call(:foo) do
-            data.update :modes => []
-            read { data.modes.push(read_mode) }
+            read { data.update :answer => 42 }
+          end
+
+          call(:bar) do
+            get { data.update :answer => 42.0 }
           end
         end
       }
     api = assert{ api_class.new }
 
-    Dao::Mode::Read.each do |mode|
-      result = assert{ api.mode(mode).call(:foo) }
-      assert{ result.data.modes == [read_mode] }
-    end
-  end
+    assert{ api.read.call(:foo).data.answer == 42 }
+    assert{ api.get.call(:foo).data.answer == 42 }
 
-  testing 'that post/put/delete/trace/connect are considered write modes' do
-    write_mode = assert{ Dao::Mode.write }
+    assert{ api.read.call(:bar).data.answer == 42.0 }
+    assert{ api.get.call(:bar).data.answer == 42.0 }
+  end
 
+  testing 'that write==post' do
     api_class =
       assert{
         Dao.api do
           call(:foo) do
-            data.update :modes => []
-            write { data.modes.push(write_mode) }
+            write { data.update :answer => 42 }
+          end
+
+          call(:bar) do
+            post { data.update :answer => 42.0 }
           end
         end
       }
     api = assert{ api_class.new }
 
-    Dao::Mode::Write.each do |mode|
-      result = assert{ api.mode(mode).call(:foo) }
-      assert{ result.data.modes == [write_mode] }
-    end
+    assert{ api.write.call(:foo).data.answer == 42 }
+    assert{ api.post.call(:foo).data.answer == 42 }
+
+    assert{ api.write.call(:bar).data.answer == 42.0 }
+    assert{ api.post.call(:bar).data.answer == 42.0 }
   end
 
-  testing 'that the first, most specific, mode block encountered fires first' do
+  testing 'that aliases are re-defined in scope' do
     api_class =
       assert{
         Dao.api do
           call(:foo) do
-            data.update :modes => []
-            Dao::Mode::Read.each do |mode|
-              send(mode){ data.modes.push(mode) }
-            end
-            read { data.modes.push(Dao::Mode.read) }
+            data.update :a => mode
+            read { data.update :b => mode }
+            write { data.update :b => mode }
+          end
+
+          call(:bar) do
+            data.update :a => mode
+            get { data.update :b => mode }
+            post { data.update :b => mode }
           end
         end
       }
     api = assert{ api_class.new }
 
-    read = Dao::Mode.read
-    result = assert{ api.mode(read).call(:foo) }
-    assert{ result.data.modes == [read] }
 
-    Dao::Mode::Read.each do |mode|
-      result = assert{ api.mode(mode).call(:foo) }
-      assert{ result.data.modes == [mode] }
+    [:foo, :bar].each do |call|
+      result = assert{ api.read.call(call) }
+      assert{ result.data[:a] = Dao::Mode.read }
+      assert{ result.data[:b] = Dao::Mode.read }
+
+      result = assert{ api.get.call(call) }
+      assert{ result.data[:a] = Dao::Mode.read }
+      assert{ result.data[:b] = Dao::Mode.get }
+
+
+      result = assert{ api.write.call(call) }
+      assert{ result.data[:a] = Dao::Mode.write }
+      assert{ result.data[:b] = Dao::Mode.write }
+
+      result = assert{ api.post.call(call) }
+      assert{ result.data[:a] = Dao::Mode.write }
+      assert{ result.data[:b] = Dao::Mode.post }
     end
   end
 

data/test/form_test.rb

@@ -91,7 +91,7 @@ Testing Dao::Form do
 
   #
     block = proc do |content, value, selected_value|
-      is_selected = value.to_s == selected_value
+      is_selected = value.to_s == selected_value.to_s
       [content, value, is_selected]
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dao
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-13 00:00:00.000000000 Z
+date: 2013-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails