dao 0.0.0 → 2.0.0

data/lib/dao/exceptions.rb

@@ -0,0 +1,2 @@
+class Error < ::StandardError
+end

data/lib/dao/form.rb

@@ -0,0 +1,236 @@
+module Dao
+  class Form
+    include Tagz.globally
+
+    class << Form 
+      def for(*args, &block)
+        new(*args, &block)
+      end
+
+      def cast(*args)
+        if args.size == 1
+          value = args.first
+          value.is_a?(self) ? value : self.for(value)
+        else
+          self.for(*args)
+        end
+      end
+    end
+
+    attr_accessor :result
+
+    def initialize(*args, &block)
+      @result = args.shift if args.first.is_a?(Result)
+      super
+    end
+
+    def params
+      result.params
+    end
+
+    def ==(other)
+      params.object_id == other.params.object_id
+    end
+
+    def errors
+      result.errors
+    end
+
+    def form(*args, &block)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      keys = args.flatten
+
+      action = options.delete(:action) || './'
+      method = options.delete(:method) || 'post'
+      id = options.delete(:id) || id_for(keys)
+      klass = class_for(keys, options.delete(:class))
+      error = error_for(keys, options.delete(:error))
+
+      content =
+        if block.nil? and !options.has_key?(:content)
+          ''
+        else
+          block ? block.call(form=self) : options.delete(:content)
+        end
+
+      form_(options_for(options, :action => action, :method => method, :class => klass, :id => id, :data_error => error)){ content }
+    end
+
+    def label(*args, &block)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      keys = args.flatten
+
+      name = options.delete(:name) || keys.last
+      id = options.delete(:id) || id_for(keys)
+      klass = class_for(keys, options.delete(:class))
+      error = error_for(keys, options.delete(:error))
+
+      content =
+        if block.nil? and !options.has_key?(:content) 
+          name.to_s.humanize
+        else
+          block ? block.call() : options.delete(:content)
+        end
+
+      label_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){ content }
+    end
+
+    def input(*args, &block)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      keys = args.flatten
+
+      type = options.delete(:type) || :text
+      name = options.delete(:name) || name_for(keys)
+      id = options.delete(:id) || id_for(keys)
+      klass = class_for(keys, options.delete(:class))
+      error = error_for(keys, options.delete(:error))
+
+      value =
+        if block.nil? and !options.has_key?(:value) 
+          value_for(params, keys)
+        else
+          block ? block.call(params.get(keys)) : options.delete(:value)
+        end
+
+      input_(options_for(options, :type => type, :name => name, :value => value, :class => klass, :id => id, :data_error => error)){}
+    end
+
+    def submit(*args, &block)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options[:type] = :submit
+      options[:value] = block ? block.call : :Submit
+      args.push(options)
+      input(*args)
+    end
+
+    def button(*args)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      keys = args.flatten
+
+      type = options.delete(:type) || :button
+      name = options.delete(:name) || name_for(keys)
+      id = options.delete(:id) || id_for(keys)
+      klass = class_for(keys, options.delete(:class))
+      error = error_for(keys, options.delete(:error))
+
+      value =
+        if block.nil? and !options.has_key?(:value) 
+          value_for(params, keys)
+        else
+          block ? block.call(params.get(keys)) : options.delete(:value)
+        end
+
+      button_(options_for(options, :type => type, :name => name, :value => value, :class => klass, :id => id, :data_error => error)){}
+    end
+
+    def reset(*args)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options[:type] = :reset
+      args.push(options)
+      button(*args)
+    end
+
+    def textarea(*args, &block)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      keys = args.flatten
+
+      name = options.delete(:name) || name_for(keys)
+      id = options.delete(:id) || id_for(keys)
+      klass = class_for(keys, options.delete(:class))
+      error = error_for(keys, options.delete(:error))
+
+      value =
+        if block.nil? and !options.has_key?(:value) 
+          value_for(params, keys)
+        else
+          block ? block.call(params.get(keys)) : options.delete(:value)
+        end
+
+      textarea_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){ value }
+    end
+
+    def select(*args, &block)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      keys = args.flatten
+
+      name = options.delete(:name) || name_for(keys)
+      from = options.delete(:from) || options.delete(:select) || options.delete(:all) || options.delete(:list)
+
+      id = options.delete(:id) || id_for(keys)
+      klass = class_for(keys, options.delete(:class))
+      error = error_for(keys, options.delete(:error))
+
+      select_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){
+        pairs = Array(params[from]).flatten
+        pairs.each do |pair|
+          result = block.call(pair)
+          case result
+            when Array
+              value, content, selected, *ignored = result
+            when Hash
+              value = result[:value]
+              content = result[:content] || value
+              selected = result[:selected]
+            else
+              value = result
+              content = result
+              selected = false
+          end
+          opts = {:value => value}
+          opts[:selected] = !!selected if selected
+          option_(opts){ content }
+        end
+      }
+    end
+
+    def id_for(keys)
+      id = [result.path, keys.join('-')].compact.join('_')
+      slug_for(id)
+    end
+
+    def class_for(keys, klass = nil)
+      klass = 
+        if result.errors.on?(keys)
+          [klass, 'dao', 'errors'].compact.join(' ')
+        else
+          [klass, 'dao'].compact.join(' ')
+        end
+      klass
+    end
+
+    def error_for(keys, klass = nil)
+      if result.errors.on?(keys)
+        result.errors.get(keys)
+      end
+    end
+
+    def value_for(params, keys)
+      return nil unless params.has?(keys)
+      value = Tagz.escapeHTML(params.get(keys))
+    end
+
+    def name_for(keys)
+      "#{ result.path }(#{ Array(keys).flatten.compact.join(',') })"
+    end
+
+    def options_for(*hashes)
+      map = Map.new
+      hashes.flatten.each do |h|
+        h.each{|k,v| map[attr_for(k)] = v unless v.nil?}
+      end
+      map
+    end
+
+    def slug_for(string)
+      string = string.to_s
+      words = string.to_s.scan(%r/\w+/)
+      words.map!{|word| word.gsub(%r/[^0-9a-zA-Z_:-]/, '')}
+      words.delete_if{|word| word.nil? or word.strip.empty?}
+      words.join('-').downcase.sub(/_+$/, '')
+    end
+
+    def attr_for(string)
+      slug_for(string).gsub(/_/, '-')
+    end
+  end
+end

data/lib/dao/mode.rb

@@ -0,0 +1,41 @@
+module Dao
+  class Mode < ::String
+    class << Mode
+      def for(mode)
+        mode.is_a?(Mode) ? mode : Mode.new(mode.to_s)
+      end
+
+      def list
+        List
+      end
+
+      def default
+        Mode.for(:read)
+      end
+    end
+
+    Verbs = %w( options get head post put delete trace connect )
+
+    Verbs.each do |verb|
+      const = verb.downcase.capitalize
+      unless const_defined?(const)
+        mode = Mode.for(verb.downcase)
+        const_set(const, mode)
+      end
+    end
+
+    Read = Get unless defined?(Read)
+    Write = Post unless defined?(Write)
+
+    List = Verbs + %w( read write )
+
+    List.each do |method|
+      const = method.downcase.capitalize
+      define_method(method){ const_get(const) }
+    end
+
+    def ==(other)
+      super(Mode.for(other))
+    end
+  end
+end

data/lib/dao/mongo_mapper.rb

@@ -0,0 +1,70 @@
+begin
+  MongoMapper
+rescue NameError
+  nil
+end
+
+if defined?(MongoMapper)
+
+  module MongoMapper
+    module ToDao
+      module ClassMethods
+        def to_dao(*args)
+
+          unless defined?(@to_dao)
+            @to_dao = column_names.map{|name| name.to_s}
+          end
+
+          unless args.empty?
+            @to_dao.clear
+            args.flatten.compact.each do |arg|
+              @to_dao.push(arg.to_s)
+            end
+            @to_dao.uniq!
+            @to_dao.map!{|name| name.to_s}
+          end
+
+          @to_dao
+        end
+      end
+
+      module InstanceMethods
+        def to_dao(*args)
+          hash = Dao.hash
+          model = self.class
+
+          attrs = args.empty? ? model.to_dao : args
+
+          attrs.each do |attr|
+            value = send(attr)
+
+            if value.respond_to?(:to_dao)
+              hash[attr] = value.to_dao
+              next
+            end
+
+            if value.is_a?(Array)
+              hash[attr] = value.map{|val| val.respond_to?(:to_dao) ? val.to_dao : val}
+              next
+            end
+
+            hash[attr] = value
+          end
+
+          if hash.has_key?(:_id) and not hash.has_key?(:id)
+            hash[:id] = hash[:_id]
+          end
+
+          hash
+        end
+        alias_method 'to_h', 'to_dao'
+      end
+    end
+
+    MongoMapper::Document::ClassMethods.send(:include, ToDao::ClassMethods)
+    MongoMapper::Document::InstanceMethods.send(:include, ToDao::InstanceMethods)
+    MongoMapper::EmbeddedDocument::ClassMethods.send(:include, ToDao::ClassMethods)
+    MongoMapper::EmbeddedDocument::InstanceMethods.send(:include, ToDao::InstanceMethods)
+  end
+
+end

data/lib/dao/params.rb

@@ -0,0 +1,109 @@
+module Dao
+  class Params < ::Map
+    class << Params
+      def parse(prefix, params = {})
+        prefix = prefix.to_s
+        params = Map.new(params)
+        parsed = Params.new
+        parsed.update(params[prefix]) if params.has_key?(prefix)
+
+        re = %r/^ #{ Regexp.escape(prefix) } (?: [(] ([^)]+) [)] )? $/x
+
+        params.each do |key, value|
+          next unless(key.is_a?(String) or key.is_a?(Symbol))
+          key = key.to_s
+          matched, keys = re.match(key).to_a
+          next unless matched
+          next unless keys
+          keys = keys.strip.split(%r/\s*,\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
+          parsed.set(keys => value)
+        end
+
+        parsed
+      end
+    end
+
+    attr_accessor :api
+    attr_accessor :endpoint
+    attr_accessor :params
+    attr_accessor :result
+
+    def Params.for(*args, &block)
+      options = Dao.options_for!(args)
+
+      api = options[:api]
+      endpoint = options[:endpoint]
+      updates = options[:params]
+
+      params = new()
+      params.api = api
+      params.endpoint = endpoint
+
+      params.update(updates) if updates
+
+      params
+    end
+
+    def path
+      result.path if result
+    end
+
+    def status(*args)
+      result.status(*args) if result
+    end
+    def status=(value)
+      result.status=value if result
+    end
+
+    def errors
+      result.errors if result
+    end
+
+    def data
+      result.data if result
+    end
+
+    def validates(*args, &block)
+      result.validates(*args, &block) if result
+    end
+
+    def validate(*args, &block)
+      result.validate(*args, &block) if result
+    end
+
+    def valid?
+      result.valid? if result
+    end
+
+    def validate!
+      result.validate! if result
+    end
+
+    unless Object.new.respond_to?(:instance_exec)
+      module InstanceExecHelper; end
+      include InstanceExecHelper
+
+      def instance_exec(*args, &block)
+        begin
+          old_critical, Thread.critical = Thread.critical, true
+          n = 0
+          n += 1 while respond_to?(mname="__instance_exec_#{ n }__")
+          InstanceExecHelper.module_eval{ define_method(mname, &block) }
+        ensure
+          Thread.critical = old_critical
+        end
+        begin
+          ret = send(mname, *args)
+        ensure
+          InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+        end
+        ret
+      end
+    end
+  end
+
+
+  def Dao.parse(*args, &block)
+    Params.parse(*args, &block)
+  end
+end