dao 3.3.0 → 4.2.1

data/lib/dao/conducer/attributes.rb

@@ -0,0 +1,21 @@
+module Dao
+  class Conducer
+    class Attributes < ::Map
+      ### Attributes.dot_keys! if Attributes.respond_to?(:dot_keys!)
+
+      class << Attributes
+        def for(*args, &block)
+          new(*args, &block)
+        end
+      end
+
+      attr_accessor :conducer
+
+      def initialize(*args, &block)
+        conducers, args = args.partition{|arg| arg.is_a?(Conducer)}
+        @conducer = conducers.shift
+        super(*args, &block)
+      end
+    end
+  end
+end

data/lib/dao/conducer/crud.rb

@@ -0,0 +1,70 @@
+module Dao
+## CRUD support
+#
+  class Conducer
+    module CRUD
+      Code = proc do
+        class << self
+          def db
+            Db.instance
+          end
+
+          def collection
+            db[collection_name]
+          end
+
+          def all(*args)
+            hashes = collection.all()
+            hashes.map{|hash| new(hash)}
+          end
+
+          def find(id)
+            hash = collection.find(id)
+            new(hash) if hash
+          end
+        end
+
+        def save
+          run_callbacks :save do
+            return(false) unless valid?
+            id = self.class.collection.save(@attributes)
+            @attributes.set(:id => id)
+            true
+          end
+        ensure
+          @new_record = false
+        end
+
+        def destroy
+          id = self.id
+          if id
+            self.class.collection.destroy(id)
+            @attributes.rm(:id)
+          end
+          id
+        ensure
+          @destroyed = true
+        end
+      end
+
+      def CRUD.included(other)
+        super
+      ensure
+        other.module_eval(&Code)
+      end
+    end
+  end
+
+## dsl for auto-crud
+#
+  class Conducer
+    class << self
+      def crud
+        include(Conducer::CRUD)
+      end
+      alias_method('crud!', 'crud')
+      alias_method('autocrud!', 'crud')
+    end
+  end
+  #Conducer::send(:include, Conducer::CRUD)
+end

data/lib/dao/current.rb

@@ -0,0 +1,66 @@
+# FIXME - the redundancy in this file fucking kilz me... fix it.
+#
+module Dao::Current
+  Methods = proc do
+  end
+
+  ClassMethods = proc do
+    def current_controller
+      @current_controller ||= (
+        if defined?(@controller)
+          @controller
+        else
+          Dao.current_controller || Dao.mock_controller
+        end
+      )
+    end
+
+    %w( request response session ).each do |attr|
+      instance_eval <<-__, __FILE__, __LINE__
+        def current_#{ attr }
+          @current_#{ attr } ||= current_controller.instance_eval{ #{ attr } }
+        end
+      __
+    end
+
+    %w( current_user effective_user real_user ).each do |attr|
+      instance_eval <<-__, __FILE__, __LINE__
+        def #{ attr }
+          @#{ attr } ||= current_controller.instance_eval{ #{ attr } }
+        end
+        def #{ attr }=(value)
+          @#{ attr } = value
+        end
+      __
+    end
+  end
+
+  InstanceMethods = proc do
+    def current_controller
+      @current_controller ||= (
+        if defined?(@controller)
+          @controller
+        else
+          self.class.current_controller
+        end
+      )
+    end
+
+    %w( current_request current_response current_session current_user effective_user real_user ).each do |attr|
+      module_eval <<-__, __FILE__, __LINE__
+        def #{ attr }
+          @#{ attr } ||= self.class.send('#{ attr }')
+        end
+        def #{ attr }=(value)
+          @#{ attr } = value
+        end
+      __
+    end
+  end
+
+  def self.included(other)
+    other.send(:instance_eval, &ClassMethods)
+    other.send(:class_eval, &InstanceMethods)
+    super
+  end
+end

data/lib/dao/db.rb

@@ -7,11 +7,23 @@ module Dao
     attr_accessor :path
 
     def initialize(*args)
-      options = Dao.options_for!(args)
-      @path = (args.shift || options[:path] || './db/dao.yml').to_s
+      options = args.extract_options!.to_options!
+      @path = ( args.shift || options[:path] || Db.default_path ).to_s
       FileUtils.mkdir_p(File.dirname(@path)) rescue nil
     end
 
+    def rm_f
+      FileUtils.rm_f(@path) rescue nil
+    end
+
+    def rm_rf
+      FileUtils.rm_rf(@path) rescue nil
+    end
+
+    def truncate
+      rm_f
+    end
+
     def db
       self
     end
@@ -53,7 +65,9 @@ module Dao
 
       def delete(id)
         @db.delete(@name, id)
+        id
       end
+      alias_method('destroy', 'delete')
 
       def to_hash
         transaction{|y| y[@name]}
@@ -73,17 +87,25 @@ module Dao
     end
     alias_method('[]', 'collection')
 
+    def method_missing(method, *args, &block)
+      if args.empty? and block.nil?
+        return self.collection(method)
+      end
+      super
+    end
+
     def transaction(*args, &block)
       ystore.transaction(*args, &block)
     end
 
-    def save(collection, data = {})
+    def save(collection, data)
       data = data_for(data)
       ystore.transaction do |y|
         collection = (y[collection.to_s] ||= {})
         id = next_id_for(collection, data)
         collection[id] = data
         record = collection[id]
+        id
       end
     end
 
@@ -133,6 +155,7 @@ module Dao
         end
       end
     end
+    alias_method('destroy', 'delete')
 
     def next_id_for(collection, data)
       data = data_for(data)
@@ -167,11 +190,11 @@ module Dao
       attr_writer :instance
 
       def default_root()
-        defined?(Rails.root) ? File.join(Rails.root.to_s, 'db') : './db'
+        defined?(Rails.root) && Rails.root ? File.join(Rails.root.to_s, 'db') : './db'
       end
 
       def default_path()
-        File.join(default_root, 'dao.yml')
+        File.join(default_root, 'db.yml')
       end
 
       def method_missing(method, *args, &block)
@@ -186,6 +209,22 @@ module Dao
       def root
         @root ||= default_root
       end
+
+      def tmp(&block)
+        require 'tempfile' unless defined?(Tempfile)
+        tempfile = Tempfile.new("#{ Process.pid }-#{ Process.ppid }-#{ Time.now.to_f }-#{ rand }")
+        path = tempfile.path
+        db = new(:path => path)
+        if block
+          begin
+            block.call(db)
+          ensure
+            db.rm_rf
+          end
+        else
+          db
+        end
+      end
     end
   end
 end

data/lib/dao/endpoint.rb

@@ -1,6 +1,6 @@
 module Dao
   class Endpoint
-    Attrs = %w( api path method doc )
+    Attrs = %w( api path route block doc )
     Attrs.each{|attr| attr_accessor(attr)}
 
     def initialize(options = {})
@@ -12,5 +12,17 @@ module Dao
         send("#{ key }=", val)
       end
     end
+
+    def arity
+      block.arity
+    end
+
+    def call(*args)
+      block.call(*args)
+    end
+
+    def to_proc
+      block
+    end
   end
 end

data/lib/dao/errors.rb

@@ -6,22 +6,28 @@ module Dao
 
     class << Errors
       include Tagz.globally
+
+      def for(*args, &block)
+        if args.size == 1 and args.first.is_a?(Errors)
+          return args.first
+        end
+        new(*args, &block)
+      end
     end
 
   # you can tweak these if you want
   #
     Global = '*' unless defined?(Global)
-    #Separator = '⇒' unless defined?(Separator)
-    Separator = "\342\207\222" unless defined?(Separator)  ### this is an "Open-outlined rightward arrow" - http://en.wikipedia.org/wiki/List_of_Unicode_characters#Supplemental_arrows-A
-
+    #Separator = "\342\207\222" unless defined?(Separator)  ### this is an "Open-outlined rightward arrow"
+    Separator = ":" unless defined?(Separator)
 
-  # string message support class - knows when it's sticky...
+  # messages know when they're sticky
   #
     class Message < ::String
       attr_accessor :sticky
 
       def initialize(*args)
-        options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+        options = Map.options_for!(args)
         replace(args.join(' '))
         @sticky = options[:sticky]
       end
@@ -42,16 +48,35 @@ module Dao
       def global_key
         [Global]
       end
-
-      def for(*args, &block)
-        new(*args, &block)
-      end
     end
 
   # instance methods
   #
+    attr_accessor :object
+
+    def initialize(*args)
+      @object = args.shift
+    end
+
+    def errors
+      self
+    end
+
+    def [](key)
+      self[key] = Array.new unless has_key?(key)
+      super
+    end
+
+    def size
+      size = 0
+      depth_first_each{|key, val| size += Array(val).size}
+      size
+    end
+    alias_method('count', 'size')
+    alias_method('length', 'size')
+
     def add(*args)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = Map.options_for!(args)
       sticky = options[:sticky]
       clear = options[:clear]
 
@@ -85,7 +110,7 @@ module Dao
 
       errors.each do |keys, message|
         list = get(keys)
-        unless get(keys)
+        unless has?(keys)
           set(keys => [])
           list = get(keys)
         end
@@ -96,42 +121,20 @@ module Dao
       
       result
     end
+
     alias_method('add_to_base', 'add')
 
     def add!(*args)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = Map.new(args.last.is_a?(Hash) ? args.last : {}) 
       options[:sticky] = true
       args.push(options)
       add(*args)
     end
-    alias_method('add_to_base!', 'add!')
 
-    def clone
-      clone = Errors.new
-      depth_first_each do |keys, message|
-        args = [*keys]
-        args.push(message)
-        clone.add(*args)
-      end
-      clone
-    end
-
-    def update(other, options = {})
-      options = Dao.map_for(options)
-      prefix = Array(options[:prefix]).flatten.compact
+    alias_method('add_to_base!', 'add!')
 
-      other.each do |key, val|
-        key = key.to_s
-        if key == 'base' or key == Global
-          add!(val)
-        else
-          key = prefix + [key] unless prefix.empty?
-          add(key, val)
-        end
-      end
-    end
+    alias_method('clear!', 'clear')
 
-    alias_method('clear!', 'clear') unless instance_methods.include?('clear!')
     def clear
       keep = []
       depth_first_each do |keys, message|
@@ -147,27 +150,21 @@ module Dao
     def invalid?(*keys)
       has?(keys) and !get(keys).nil?
     end
+
     alias_method('on?', 'invalid?')
 
     def on(*args, &block)
       get(*args, &block)
     end
 
-    def size
-      size = 0
-      depth_first_each{ size += 1 }
-      size
-    end
-    alias_method('count', 'size')
-    alias_method('length', 'size')
-
     def full_messages
       global_messages = []
       full_messages = []
 
       depth_first_each do |keys, value|
         index = keys.pop
-        key = keys.join('.')
+        key = keys
+        #key = keys.join('.')
         value = value.to_s
         next if value.strip.empty?
         if key == Global
@@ -191,6 +188,7 @@ module Dao
     def each_full_message
       full_messages.each{|msg| yield msg}
     end
+
     alias_method('each_full', 'each_full_message')
 
     def messages
@@ -215,25 +213,42 @@ module Dao
 
     def Errors.default_errors_to_html(*args)
       error = args.shift
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = Map.options_for!(args)
       errors = [error, *args].flatten.compact
 
       at_least_one_error = false
-      css_class = options[:class] || 'dao errors'
+      css_class = options[:class] || 'errors dao'
 
       to_html =
-        table_(:class => css_class){
-          caption_{ "We're so sorry, but can you please fix the following errors?" }
-          errors.each do |e|
-            e.full_messages.each do |key, message|
-              at_least_one_error = true
-              tr_{
-                td_(:class => :key){ key }
-                td_(:class => :separator){ Separator }
-                td_(:class => :message){ message }
-              }
+        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
-          end
+            __
+          }
+          __
         }
 
       at_least_one_error ? to_html : ''