dao 4.2.1 → 4.4.2

data/lib/dao/api/{endpoints.rb → call.rb}

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Api
   # class methods

data/lib/dao/api/context.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Context
     Attrs = %w(
@@ -42,6 +43,7 @@ module Dao
       @result = Result.new
       @result.path = @path
       @result.route = @route
+      @result.status = @status
       @result.mode = @api.mode
       @result.params = @params
       @result.errors = @params.errors

data/lib/dao/api/dsl.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Api
     class DSL < BlankSlate

data/lib/dao/api/initializers.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Api
     Initializers = {} unless defined?(Initializers)

data/lib/dao/api/modes.rb

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

data/lib/dao/api/routes.rb

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

data/lib/dao/blankslate.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class BlankSlate
     instance_methods.each{|m| undef_method(m) unless m.to_s =~ /(^__)|object_id/}

data/lib/dao/conducer.rb

@@ -1,36 +1,37 @@
+# -*- encoding : utf-8 -*-
 module Dao
-
-  class Conducer
 ##
-#      
-    include ActiveModel::Naming
-    #include ActiveModel::Conversion
-
-    #extend ActiveModel::Translation
-    #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
+#
+  Dao.load('conducer/attributes.rb')
+  Dao.load('conducer/collection.rb')
+  Dao.load('conducer/active_model.rb')
+  Dao.load('conducer/controller_support.rb')
+  Dao.load('conducer/callback_support.rb')
+  Dao.load('conducer/view_support.rb')
+  Dao.load('conducer/nav_support.rb')
 
 ##
 #
+  class Conducer
+  ##
+  #
     include Dao::Validations
-    include Dao::Current
 
-## class_methods
-#
+  ## class_methods
+  #
     class << Conducer
+      def inherited(other)
+        super
+      ensure
+        other.build_collection_class!
+        subclasses.push(other)
+        subclasses.uniq!
+      end
+
+      def subclasses
+        defined?(@@subclasses) ? @@subclasses : (@@subclasses = [])
+      end
+
       def name(*args)
         return send('name=', args.first) unless args.empty?
         @name ||= super
@@ -40,43 +41,16 @@ module Dao
         @name = name.to_s
       end
 
-      def model_name(*args)
-        return send('model_name=', args.first) 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
-        model_name_for(name.to_s.sub(/Conducer$/, ''))
-      end
-
-      def table_name
-        @table_name ||= model_name.plural.to_s
-      end
-      alias_method('collection_name', 'table_name')
-
-      def table_name=(table_name)
-        @table_name = table_name.to_s 
-      end
-      alias_method('collection_name=', 'table_name=')
-
       def controller
-        defined?(@controller) ? @controller : Dao.current_controller
+        Dao.current_controller || Dao.mock_controller
       end
 
       def controller=(controller)
-        @controller = controller
+        Dao.current_controller = controller
       end
 
-      def mock_controller(*args, &block)
-        Dao.mock_controller(*args, &block)
+      def current
+        @current ||= (defined?(::Current) ? ::Current : Map.new)
       end
 
       def raise!(*args, &block)
@@ -93,324 +67,382 @@ module Dao
       end
     end
 
-## contructor 
-#
-    %w(
-      name
-      attributes
-      errors
-      form
-    ).each{|a| fattr(a)}
-
-    def self.new(*args, &block)
+  ## crud-y lifecycle ctors
+  #
+    def Conducer.for(action, *args, &block)
       allocate.tap do |conducer|
-        conducer.running_callbacks(:reset, :initialize) do
-          conducer.send(:reset, *args, &block)
-          conducer.send(:initialize, *args, &block)
-        end
+        action = Action.new(action, conducer)
+        Dao.call(conducer, :init, action, *args, &block)
+        Dao.call(conducer, :initialize, *args, &block)
       end
     end
 
-    def running_callbacks(*args, &block)
-      which = args.shift
-      if args.empty?
-        run_callbacks(which, &block)
-      else
-        run_callbacks(which){ running_callbacks(*args, &block) }
+    def Conducer.call(*args, &block)
+      self.for(*args, &block)
+    end
+
+    %w( new create edit update destroy ).each do |action|
+      module_eval <<-__, __FILE__, __LINE__
+        def Conducer.for_#{ action }(*args, &block)
+          Conducer.for(#{ action.inspect }, *args, &block)
+        end
+      __
+    end
+
+  ## ctor
+  #
+    def Conducer.new(*args, &block)
+      allocate.tap do |conducer|
+        Dao.call(conducer, :init, *args, &block)
+        Dao.call(conducer, :initialize, *args, &block)
       end
     end
 
-    def reset(*args, &block)
+    %w[
+      name
+      attributes
+      form
+      params
+      errors
+      status
+      models
+      model
+      conduces
+    ].each{|attr| fattr(attr)}
+
+  ## init runs *before* initialize - aka inside allocate
+  #
+    def init(*args, &block)
       controllers, args = args.partition{|arg| arg.is_a?(ActionController::Base)}
+      actions, args = args.partition{|arg| arg.is_a?(Action)}
+      models, args = args.partition{|arg| arg.respond_to?(:persisted?) }
       hashes, args = args.partition{|arg| arg.is_a?(Hash)}
 
-      @name = self.class.model_name.singular
+      @name = self.class.model_name.singular.sub(/_+$/, '')
       @attributes = Attributes.for(self)
       @form = Form.for(self)
+      @params = Map.new
 
-      validator.reset
+      @errors = validator.errors
+      @status = validator.status
 
       set_controller(controllers.shift || Dao.current_controller || Dao.mock_controller)
 
-      hashes.each do |hash|
-        hash.each do |key, val|
-          @attributes.set(key_for(key) => val)
-        end
-      end
+      set_action(actions.shift) unless actions.empty?
 
-      self
+      set_models(models)
+
+      set_mounts(self.class.mounted)
+
+      update_params(hashes)
+
+      @default_initialize = nil
     end
 
-    def errors
-      validator.errors
+    def set_models(*models)
+      @models =
+        models.flatten.compact
+
+      candidates =
+        @models.select{|model| model.class.model_name == self.class.model_name}
+
+      @model =
+        case candidates.size == 1
+          when 1
+            candidates.first
+          else
+            @models.first
+        end
+
+      @models.each do |model|
+        key = model_key_for(model)
+        ivar = "@#{ key }"
+        instance_variable_set(ivar, model) unless instance_variable_defined?(ivar)
+      end
     end
 
-    def status
-      validator.status
+    def update_params(*hashes)
+      hashes.flatten.compact.each{|hash| @params.apply(hash)}
     end
 
+  ## a sane initialize is provided for you.  you are free to override it
+  # *** without *** calling super
+  #
     def initialize(*args, &block)
+      initialize_for_action(*args, &block)
+      update_models(models) unless models.empty?
+      update_attributes(params) unless params.empty?
     end
 
-## instance_methods
-#
-    def inspect
-      ::JSON.pretty_generate(@attributes, :max_nesting => 0)
+    def set_mounts(list)
+      list.each do |args, block|
+        mount(*args, &block)
+      end
     end
 
-    def id
-      @attributes[:id] || @attributes[:_id]
+    def model_key_for(model)
+      case model
+        when String
+          model
+        else
+          model.class.name
+      end.demodulize.underscore
     end
 
-    def id=(id)
-      @attributes[:id] = id
+    def initialize_for_action(*args, &block)
+      @action.call(:initialize, *args, &block)
     end
 
-    def key_for(*keys)
-      keys.flatten.map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
-      #key = keys.flatten.join('.').strip
-      #key.split(%r/\s*[,.]\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
+    def conduces(*args)
+      if args.empty?
+        @model
+      else
+        @model = args.flatten.compact.first
+        @models.delete(@model)
+        @models.unshift(@model)
+        @model
+      end
     end
+    alias_method(:set_model, :conduces)
 
-    def [](key)
-      @attributes.get(key_for(key))
+    def conduces=(model)
+      conduces(model)
     end
 
-    def []=(key, val)
-      @attributes.set(key_for(key), val)
+    def conduces?(model)
+      conduces == model
     end
 
-    %w( set get has? update ).each do |m|
-      module_eval <<-__, __FILE__, __LINE__
-        def #{ m }(*a, &b)
-          @attributes.#{ m }(*a, &b)
+    def update_models(*models)
+      models.flatten.compact.each do |model|
+        if conduces?(model)
+          update_attributes(model.attributes)
+        else
+          update_attributes(model_key_for(model), model.attributes)
         end
-      __
+      end
     end
 
-    def method_missing(method, *args, &block)
-      case method.to_s
-        when /^(.*)[=]$/
-          key = key_for($1)
-          val = args.first
-          @attributes.set(key => val)
-
-        when /^(.*)[!]$/
-          key = key_for($1)
-          val = true
-          @attributes.set(key => val)
+    def update_attributes(*args, &block)
+      attributes =
+        case
+          when args.size == 1 && args.first.is_a?(Hash)
+            args.first
+          else
+            if args.size >= 2
+              val = args.pop
+              key = args.flatten.compact
+              {key => val}
+            else
+              {}
+            end
+        end
 
-        when /^(.*)[?]$/
-          key = key_for($1)
-          @attributes.has?(key)
+      @attributes.set(attributes)
 
-        else
-          key = key_for(method)
-          return @attributes.get(key) if @attributes.has?(key)
-          super
-      end
-    end
+      update_mounted_attributes!
 
-    def inspect
-      "#{ self.class.name }(#{ @attributes.inspect.chomp })"
+      @attributes
     end
 
-# active_model support
-#
-
+    def update_mounted_attributes!
+      deepest_mounts_first = mounted.sort_by{|mnt| mnt._key.size}.reverse
 
-## include ActiveModel::Conversion
-#
-    def to_model
-      self
+      deepest_mounts_first.each do |mount|
+        value = @attributes.get(mount._key)
+        mount._set(value) if mount.respond_to?(:_set)
+        @attributes.set(mount._key => mount)
+      end
     end
 
-    def to_key
-      id ? [id] : nil
+    def update_attributes!(*args, &block)
+      update_attributes(*args, &block)
+    ensure
+      save!
     end
 
-    def to_param
-      persisted? ? to_key.join('-') : nil
+    def attributes=(attributes)
+      @attributes.clear
+      update_attributes(attributes)
     end
 
-    def persisted
-      !!(defined?(@persisted) ? @persisted : id)
-    end
-    def persisted?
-      persisted
-    end
-    def persisted=(value)
-      @persisted = !!value
-    end
-    def persisted!
-      self.persisted = true
+    def set(*args, &block)
+      update_attributes(*args, &block)
     end
 
-    def new_record
-      !!(defined?(@new_record) ? @new_record : id.blank?)
-    end
-    def new_record?
-      new_record
+    def has?(*key)
+      key = key_for(key)
+      @attributes.has?(key)
     end
-    def new_record=(value)
-      @new_record = !!value
+
+    def get(*key)
+      key = key_for(key)
+      @attributes.get(key)
     end
-    def new_record!
-      self.new_record = true
+
+    def [](key)
+      get(key)
     end
 
-    def destroyed
-      !!(defined?(@destroyed) ? @destroyed : id.blank?)
+    def []=(key, val)
+      set(key, val)
     end
-    def destroyed?
-      destroyed
+
+    def method_missing(method, *args, &block)
+      re = /^([^=!?]+)([=!?])?$/imox
+
+      matched, key, suffix = re.match(method.to_s).to_a
+      
+      case suffix
+        when '='
+          set(key, args.first)
+        when '!'
+          set(key, args.size > 0 ? args.first : true)
+        when '?'
+          has?(key)
+        else
+          case key
+            when /^current_(.*)/
+              Current.send($1)
+            else
+              has?(key) ? get(key) : super
+          end
+      end
     end
-    def destroyed=(value)
-      @destroyed = !!value
+
+  ## id support 
+  #
+    def id(*args)
+      if args.blank?
+        @attributes[:_id] || @attributes[:id]
+      else
+        id = args.flatten.compact.shift
+        key = [:_id, :id].detect{|k| @attributes.has_key?(k)} || :id
+        @attributes[key] = id_for(id)
+      end
     end
-    def destroyed!
-      self.destroyed = true
+
+    def id?
+      self.id
     end
 
+    def id=(id)
+      self.id(id)
+    end
 
-## extend ActiveModel::Translation
-#
-    def self.human_attribute_name(attribute, options = {})
-      attribute
+    def id!(id)
+      self.id(id)
     end
 
-    def self.lookup_ancestors
-      [self]
+    def id_for(object)
+      model?(object) ? object.id : object
     end
 
-    def read_attribute_for_validation(key)
-      self[key]
+    def model?(object)
+      object.respond_to?(:persisted?)
     end
 
-## view support
-#
-    url_helpers = Rails.application.try(:routes).try(:url_helpers)
-    include(url_helpers) if url_helpers
-    include(ActionView::Helpers) if defined?(ActionView::Helpers)
+  ## mixin controller support
+  #
+    module_eval(&ControllerSupport)
 
-    def controller
-      @controller ||= (Dao.current_controller || Dao.mock_controller)
-      @controller
-    end
+  ## mixin callback support
+  #
+    module_eval(&CallbackSupport)
 
-    def 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
-    end
+  ## mixin view support
+  #
+    module_eval(&ViewSupport)
 
-    def set_controller(controller)
-      self.controller = controller
+  ##
+  #
+    def save
+      default_save
     end
 
-    controller_delegates = %w(
-      render
-      render_to_string
-    )
+    def default_save
+      return false unless valid?
 
-    controller_delegates.each do |method|
-      module_eval <<-__, __FILE__, __LINE__
-        def #{ method }(*args, &block)
-          controller.#{ method }(*args, &block)
+      if @model
+        attributes = self.attributes.dup
+
+        @models.each do |model|
+          next if model == @model
+          key = model_key_for(model)
+          attributes.delete(key)
         end
-      __
-    end
 
-## generic crud support assuming valid .all, .find, #save and #destroy
-#
-=begin
-    def self.create(*args, &block)
-      allocate.tap do |conducer|
-        conducer.running_callbacks :reset, :initialize, :create do
-          conducer.send(:reset, *args, &block)
-          conducer.send(:initialize, *args, &block)
-          return false unless conducer.save
+        mounted.each do |mnt|
+          attributes.set(mnt._key, mnt._value)
         end
-      end
-    end
 
-    def self.create!(*args, &block)
-      allocate.tap do |conducer|
-        conducer.running_callbacks :reset, :initialize, :create do
-          conducer.send(:reset, *args, &block)
-          conducer.send(:initialize, *args, &block)
-          raise!(:validation_error) unless conducer.save
+        @model.update_attributes(attributes)
+
+        if @model.save
+          mounted.each{|mnt| mnt._clear}
+          return true
+        else
+          errors.relay(@model.errors)
+          return false
         end
+      else
+        raise NotImplementedError
       end
     end
-
-    def self.blank(params = {})
-      new
+    
+    def save!
+      raise!(:validation_error, errors) unless !!save
+      true
     end
 
-    def self.build(params = {})
-      new
+    def destroy
+      if @model and @model.destroy
+        return true
+      else
+        raise NotImplementedError
+      end
     end
 
-    def self.show(id)
-      find(id)
+    def destroy!
+      raise!(:deletion_error) unless !!destroy
+      true
     end
 
-    def self.index(params = {})
-      all(params)
+  ## misc
+  #
+    def mount(object, *args, &block)
+      mounted = object.mount(self, *args, &block)
+    ensure
+      if mounted
+        Dao.ensure_interface!(mounted, :_set, :_key, :_value, :_clear)
+        self.mounted.push(mounted)
+      end
     end
 
-    def self.edit(id)
-      find(id)
+    def mounted
+      @mounted ||= []
     end
 
-    def self.update(id)
-      find(id)
+    def self.mount(*args, &block)
+      mounted.push([args, block])
     end
 
-    def self.destroy(id)
-      find(id)
+    def self.mounted
+      @mounted ||= []
     end
-=end
 
-  ##
-  #
-
-  ##
-  #
-    def reload
-      attributes =
-        if id
-          conducer = self.class.find(id)
-          conducer ? conducer.attributes : {}
-        else
-          {}
-        end
-      reset(attributes)
-      self
+    def key_for(key)
+      Dao.key_for(key)
     end
 
-    def save!
-      saved = !!save
-      raise!(:validation_error) unless saved
-      true
-    end
-
-    def update_attributes(attributes = {})
-      @attributes.set(attributes)
-      @attributes
+    def errors
+      validator.errors
     end
 
-    def update_attributes!(*args, &block)
-      update_attributes(*args, &block)
-    ensure
-      save!
+    def status
+      validator.status
     end
 
-  ## misc
-  #
     def model_name
       self.class.model_name
     end
@@ -419,19 +451,28 @@ module Dao
       @form
     end
 
+    def helper
+      @helper ||= ::Helper.new
+    end
+
     def raise!(*args, &block)
       self.class.raise!(*args, &block)
     end
 
-    def as_json
+    def as_json(*args, &block)
       @attributes
     end
 
     def conducer
       self
     end
-  end
 
-  Dao.load('conducer/attributes.rb')
-  Dao.load('conducer/crud.rb')
+    def inspect
+      "#{ self.class.name }(#{ @attributes.inspect.chomp })"
+    end
+
+    def to_s
+      inspect
+    end
+  end
 end