dao 4.2.1 → 4.4.2

data/lib/dao/conducer/active_model.rb

@@ -0,0 +1,98 @@
+module Dao
+  class Conducer
+    include ActiveModel::Naming
+    include ActiveModel::Conversion
+    extend ActiveModel::Translation
+
+=begin
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Serialization
+    include ActiveModel::Dirty
+    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::Observing
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include ActiveModel::Validations
+    extend ActiveModel::Callbacks
+    define_model_callbacks(:save, :create, :update, :destroy)
+    define_model_callbacks(:reset, :initialize, :find, :touch)
+    include ActiveModel::Validations::Callbacks
+=end
+
+    class << Conducer
+      def model_name(*args)
+        return send('model_name=', args.first.to_s) unless args.empty?
+        @model_name ||= default_model_name
+      end
+
+      def model_name=(model_name)
+        @model_name = model_name_for(model_name)
+      end
+
+      def model_name_for(model_name)
+        ActiveModel::Name.new(Map[:name, model_name])
+      end
+
+      def default_model_name
+        return model_name_for('Conducer') if self == Dao::Conducer
+        model_name_for(name.to_s.sub(/Conducer$/, '').sub(/(:|_)+$/, ''))
+      end
+
+      def collection_name
+        @collection_name ||= model_name.plural.to_s
+      end
+      alias_method('table_name', 'collection_name')
+
+      def collection_name=(collection_name)
+        @collection_name = collection_name.to_s
+      end
+      alias_method('set_collection_name', 'collection_name=')
+      alias_method('table_name=', 'collection_name=')
+      alias_method('set_table_name', 'collection_name=')
+    end
+    
+    def persisted
+      !!(defined?(@persisted) ? @persisted : @model ? @model.persisted? : !id.blank?)
+    end
+    def persisted?
+      persisted
+    end
+    def persisted=(value)
+      @persisted = !!value
+    end
+    def persisted!
+      self.persisted = true
+    end
+
+    def new_record
+      !!(defined?(@new_record) ? @new_record : @model ? @model.new_record? : id.blank?)
+    end
+    def new_record?
+      new_record
+    end
+    def new_record=(value)
+      @new_record = !!value
+    end
+    def new_record!
+      self.new_record = true
+    end
+
+    def destroyed
+      !!(defined?(@destroyed) ? @destroyed : @model ? @model.destroyed : id.blank?)
+    end
+    def destroyed?
+      destroyed
+    end
+    def destroyed=(value)
+      @destroyed = !!value
+    end
+    def destroyed!
+      self.destroyed = true
+    end
+
+    def read_attribute_for_validation(key)
+      get(key)
+    end
+
+  end
+end

data/lib/dao/conducer/attributes.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Conducer
     class Attributes < ::Map

data/lib/dao/conducer/autocrud.rb

@@ -0,0 +1,58 @@
+# -*- encoding : utf-8 -*-
+module Dao
+  class << Conducer
+    def autocrud!
+      include(Conducer::AutoCRUD)
+    end
+    alias_method('crud!', 'autocrud!')
+  end
+
+  class Conducer
+    module AutoCRUD
+      Code = proc do
+        class << self
+          def db
+            @db ||= Db.instance
+          end
+
+          def db_collection
+            db.collection(collection_name)
+          end
+
+          def all(*args)
+            hashes = db_collection.all()
+            hashes.map{|hash| new(hash)}
+          end
+
+          def find(*args)
+            options = args.extract_options!.to_options!
+            id = args.shift || options[:id]
+            hash = db_collection.find(id)
+            new(hash) if hash
+          end
+        end
+
+        def save
+          id = self.class.db_collection.save(@attributes)
+          @attributes.set(:id => id)
+          true
+        end
+
+        def destroy
+          id = self.id
+          if id
+            self.class.db_collection.destroy(id)
+            @attributes.rm(:id)
+          end
+          id
+        end
+      end
+
+      def AutoCRUD.included(other)
+        super
+      ensure
+        other.module_eval(&Code)
+      end
+    end
+  end
+end

data/lib/dao/conducer/callback_support.rb

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+module Dao
+  class Conducer
+    CallbackSupport = proc do
+      include Wrap
+
+      class << self
+        def method_missing(method, *args, &block)
+          case method.to_s
+            when %r/\A(before|after)_(.*)\Z/
+              lifecycle, method = $1, $2
+              send(lifecycle, method, *args, &block)
+            else
+              super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dao/conducer/collection.rb

@@ -0,0 +1,45 @@
+module Dao
+  class Conducer
+    class << Conducer
+      fattr(:collection_class)
+
+      def build_collection_class!
+        conducer_class = self
+        collection_class = const_set(:Collection, Class.new(Collection){})
+        collection_class.conducer_class = conducer_class
+        conducer_class.collection_class = collection_class
+      end
+
+      def collection_for(models, *args, &block)
+        collection_class.load(models, *args, &block)
+      end
+    end
+
+    class Collection < ::Array
+      class << Collection
+        fattr(:conducer_class)
+
+        def load(*args, &block)
+          new.tap{|collection| collection.load(*args, &block)}
+        end
+      end
+
+      fattr(:models)
+
+      def conducer_class
+        self.class.conducer_class
+      end
+
+      def load(models, *args, &block)
+        block ||= proc{|model| conducer_class.new(model, *args) }
+        (self.models = models).each{|model| self << block.call(model, *args)}
+        self
+      end
+
+      def method_missing(method, *args, &block)
+        return(models.send(method, *args, &block)) if models.respond_to?(method)
+        super
+      end
+    end
+  end
+end

data/lib/dao/conducer/controller_support.rb

@@ -0,0 +1,104 @@
+# -*- encoding : utf-8 -*-
+module Dao
+  class Conducer
+    ControllerSupport = proc do
+    ##
+    #
+      def controller
+        unless defined?(@controller)
+          set_controller(Conducer.controller)
+        end
+        @controller
+      end
+
+      def controller=(controller)
+        set_controller(controller)
+      end
+
+      def set_controller(controller)
+        @controller = controller
+      ensure
+        default_url_options[:protocol] = @controller.request.protocol
+        default_url_options[:host] = @controller.request.host
+        default_url_options[:port] = @controller.request.port
+        @action = Action.new(@controller.send(:action_name).to_s, self)
+      end
+
+    ##
+    #
+      class Action < ::String
+        fattr :conducer
+
+        def initialize(action, conducer = nil)
+          super(action.to_s.downcase.strip)
+          @conducer = conducer
+        end
+
+        def action
+          to_s
+        end
+
+        def ==(other)
+          super(other.to_s)
+        end
+
+        Synonyms = {
+          'new'    => 'create',
+          'create' => 'new',
+
+          'edit'   => 'update',
+          'update' => 'edit'
+        }
+
+        def call(method, *args, &block)
+          return unless conducer
+
+          action_method = "#{ method }_for_#{ action }"
+
+          return Dao.call(conducer, action_method, *args, &block) if conducer.respond_to?(action_method)
+
+          if((synonym = Synonyms[action]))
+            action_method = "#{ method }_for_#{ synonym }"
+            return Dao.call(conducer, action_method, *args, &block) if conducer.respond_to?(action_method)
+          end
+
+          nil
+        end
+      end
+
+      def action
+        unless defined?(@action)
+          set_action(:new)
+        end
+        @action
+      end
+
+      def set_action(action)
+        unless action.is_a?(Action)
+          action = Action.new(action)
+        end
+        action.conducer = self
+        @action = action
+      end
+
+      def action=(action)
+        set_action(action)
+      end
+
+    ##
+    #
+      controller_delegates = %w(
+        render
+        render_to_string
+      )
+
+      controller_delegates.each do |method|
+        module_eval <<-__, __FILE__, __LINE__
+          def #{ method }(*args, &block)
+            controller.#{ method }(*args, &block)
+          end
+        __
+      end
+    end
+  end
+end

data/lib/dao/conducer/nav_support.rb

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+module Dao
+  class Conducer
+    def nav_for(name, &block)
+      Nav.new(name, &block).for(controller)
+    end
+    alias_method(:nav, :nav_for)
+  end
+end

data/lib/dao/conducer/view_support.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module Dao
+  class Conducer
+    ViewSupport = proc do
+      include Tagz.globally
+
+      class << Conducer
+        include Tagz.globally
+      end
+
+      url_helpers = Rails.application.try(:routes).try(:url_helpers)
+      include(url_helpers) if url_helpers
+      include(ActionView::Helpers) if defined?(ActionView::Helpers)
+    end
+  end
+end

data/lib/dao/data.rb

@@ -1,9 +1,10 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Data < ::Map
   # look good for inspect
   #
     def inspect
-      ::JSON.pretty_generate(self, :max_nesting => 0)
+      Dao.json_for(self)
     end
 
   # support updates with dao-ish objects

data/lib/dao/db.rb

@@ -1,3 +1,5 @@
+# -*- encoding : utf-8 -*-
+
 require 'yaml'
 require 'yaml/store'
 require 'fileutils'

data/lib/dao/endpoint.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Endpoint
     Attrs = %w( api path route block doc )

data/lib/dao/engine.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   if(defined?(Rails) && Rails::VERSION::MAJOR == 3)
     class Engine < Rails::Engine

data/lib/dao/errors.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Errors < ::Map
   # for html generation
@@ -18,23 +19,18 @@ module Dao
   # you can tweak these if you want
   #
     Global = '*' unless defined?(Global)
-    #Separator = "\342\207\222" unless defined?(Separator)  ### this is an "Open-outlined rightward arrow"
-    Separator = ":" unless defined?(Separator)
+    Separator = "\342\207\222" unless defined?(Separator)  ### this is an "Open-outlined rightward arrow"
+    #Separator = ":" unless defined?(Separator)
 
   # messages know when they're sticky
   #
     class Message < ::String
-      attr_accessor :sticky
+      attr_accessor :source
 
       def initialize(*args)
         options = Map.options_for!(args)
         replace(args.join(' '))
-        @sticky = options[:sticky]
-      end
-
-      def sticky?
-        @sticky ||= nil
-        !!@sticky
+        self.source = options[:source]
       end
 
       def to_s
@@ -58,94 +54,114 @@ module Dao
       @object = args.shift
     end
 
-    def errors
-      self
-    end
-
     def [](key)
-      self[key] = Array.new unless has_key?(key)
+      return [] unless has_key?(key)
       super
     end
 
+    def errors
+      self
+    end
+
     def size
       size = 0
-      depth_first_each{|key, val| size += Array(val).size}
+      depth_first_each do |keys, value|
+        size += Array(value).size
+      end
       size
     end
     alias_method('count', 'size')
     alias_method('length', 'size')
 
+    def empty?
+      size == 0
+    end
+
     def add(*args)
+      return relay(args.first) if args.size == 1 and relay?(args.first)
       options = Map.options_for!(args)
-      sticky = options[:sticky]
+
       clear = options[:clear]
+      source = options[:source]
 
       args.flatten!
-      message = args.pop
-      keys = args
-      keys = [Global] if keys.empty?
-      errors = Hash.new
 
-      if Array(keys) == [Global]
-        sticky = true unless options.has_key?(:sticky)
-      end
+      message = args.pop or raise(ArgumentError, 'no message!')
+      key = args.empty? ? [Global] : args
 
-      sticky = true if(message.respond_to?(:sticky?) and message.sticky?)
-
-      if message
-        if message.respond_to?(:full_messages)
-          message.depth_first_each do |keys, msg|
-            errors[keys] = Message.new(msg, :sticky => sticky)
+      if message.is_a?(Hash) or message.respond_to?(:full_messages)
+        message.each do |k, v|
+          Array(v).each do |msg|
+            add(key + [k], msg)
           end
-        else
-          errors[keys] = Message.new(message, :sticky => sticky)
         end
-      else
-        raise(ArgumentError, 'no message!')
+        return(self)
       end
 
-      message = Message.new(message) unless message.is_a?(Message)
+      message = message.is_a?(Message) ? message : Message.new(message)
+      message.source = source
 
-      result = []
+      set(key => []) unless has?(key)
+      list = get(key)
+      list.clear if clear
+      list.push(message)
+      list.uniq!
+      list
+      self
+    end
+    alias_method('add!', 'add')
+    alias_method('add_to_base', 'add')
+    alias_method('add_to_base!', 'add!')
 
-      errors.each do |keys, message|
-        list = get(keys)
-        unless has?(keys)
-          set(keys => [])
-          list = get(keys)
-        end
-        list.clear if clear
-        list.push(message)
-        result = list
+    def relay(other, options = {})
+      case
+        when other.respond_to?(:each)
+          other.each do |key, messages|
+            Array(messages).each do |message|
+              add(key, message, options = {})
+            end
+          end
+        when other.respond_to?(:each_pair)
+          other.each_pair do |key, messages|
+            Array(messages).each do |message|
+              add(key, message, options = {})
+            end
+          end
+
+        when other.respond_to?(:each_slice)
+          Array(other).flatten.each_slice(2) do |key, messages|
+            Array(messages).each do |message|
+              add(key, message, options = {})
+            end
+          end
+
+        else
+          raise(ArgumentError, other.class.name)
       end
-      
-      result
+      self
     end
 
-    alias_method('add_to_base', 'add')
-
-    def add!(*args)
-      options = Map.new(args.last.is_a?(Hash) ? args.last : {}) 
-      options[:sticky] = true
-      args.push(options)
-      add(*args)
+    def relay?(arg)
+      [:each, :each_pair, :each_slice].any?{|method| arg.respond_to?(method)}
     end
 
-    alias_method('add_to_base!', 'add!')
+    def add_from_source(keys, callback, message)
+      add(keys, message, :source => callback)
+      self
+    end
 
-    alias_method('clear!', 'clear')
+    def delete_from_source(keys, callback)
+      if((messages = errors.on(keys)))
+        messages.delete_if{|m| m.respond_to?(:source) and m.source==callback}
+        rm(*keys) if messages.empty?
+      end
+      self
+    end
 
     def clear
-      keep = []
-      depth_first_each do |keys, message|
-        index = keys.pop
-        args = [keys, message].flatten
-        keep.push(args) if message.sticky?
-      end
-      clear!
-    ensure
-      keep.each{|args| add!(*args)}
+      super
     end
+    alias_method('clear!', 'clear')
 
     def invalid?(*keys)
       has?(keys) and !get(keys).nil?
@@ -164,7 +180,6 @@ module Dao
       depth_first_each do |keys, value|
         index = keys.pop
         key = keys
-        #key = keys.join('.')
         value = value.to_s
         next if value.strip.empty?
         if key == Global
@@ -217,41 +232,36 @@ module Dao
       errors = [error, *args].flatten.compact
 
       at_least_one_error = false
-      css_class = options[:class] || 'errors dao'
-
-      to_html =
-        div_(:class => css_class){
-          __
-
-          div_(:class => :caption){ "We're so sorry, but can you please fix the following errors?" }
-          __
-
-          ul_{
-            __
-            errors.each do |e|
-              e.full_messages.each do |key, message|
-                at_least_one_error = true
-                title = Array(key).join(' ').titleize
-
-                error_class = Array(key)==Array(Global) ? "global-error" : "field-error"
-                title_class = "title"
-                separator_class = "separator"
-                message_class = "message"
-
-                li_(:class => error_class){
-                  span_(:class => title_class){ title }
-                  span_(:class => separator_class){ " #{ Separator } " }
-                  span_(:class => message_class){ message }
-                }
-                __
-              end
-            end
-            __
-          }
-          __
-        }
 
-      at_least_one_error ? to_html : '' 
+      emap = Map.new
+
+      errors.each do |e|
+        e.full_messages.each do |key, message|
+          at_least_one_error = true
+          emap[key] ||= message
+        end
+      end
+
+      return "" unless at_least_one_error
+
+      div_(:class => "dao errors summary"){
+        __
+
+        h3_(:class => "caption"){ "We're so sorry, but can you please fix the following errors?" }
+        __
+
+        dl_(:class => "list"){
+          emap.each do |key, message|
+            title = Array(key).join(" ").titleize
+
+            type = Array(key) == Array(Global) ? "global" : "field"
+
+            dt_(:class => "title #{ type }"){ title }
+            dd_(:class => "message #{ type }"){ message }
+          end
+        }
+        __
+      }
     end
 
     def to_s(*args, &block)