dao 2.2.3 → 3.1.0

data/lib/dao/params.rb

@@ -1,7 +1,11 @@
 module Dao
   class Params < ::Map
-    include Dao::InstanceExec
+  # mixins
+  #
+    include Validations::Mixin
 
+  # class methods
+  #
     class << Params
       def parse(prefix, params = {}, options = {})
         prefix = prefix.to_s
@@ -60,64 +64,42 @@ module Dao
       end
     end
 
-    attr_accessor :api
-    attr_accessor :interface
-    attr_accessor :params
+  # instance methods
+  #
     attr_accessor :result
-
-    def Params.for(*args, &block)
-      options = Dao.options_for!(args)
-
-      api = options[:api]
-      interface = options[:interface]
-      updates = options[:params]
-
-      params = new()
-      params.api = api
-      params.interface = interface
-
-      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
+    attr_accessor :route
+    attr_accessor :path
+    attr_accessor :status
+    attr_accessor :errors
+    attr_accessor :validations
+    attr_accessor :form
+
+    def initialize(*args, &block)
+      @path = Path.default
+      @status = Status.default
+      @errors = Errors.new
+      @validations = Validations.for(self)
+      @form = Form.for(self)
+      super
     end
 
-    def errors
-      result.errors if result
+  # look good for inspect
+  #
+    def inspect
+      ::JSON.pretty_generate(self, :max_nesting => 0)
     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
+  # support updates with dao-ish objects
+  #
+    add_conversion_method!(:to_dao)
+    add_conversion_method!(:as_dao)
 
-    def valid?
-      result.valid? if result
-    end
-
-    def validate!
-      result.validate! if result
+    def update(*args, &block)
+      if args.size==1 and args.first.respond_to?(:to_dao)
+        to_dao = args.first.to_dao
+        return super(to_dao)
+      end
+      super
     end
   end
-
-  def Dao.parse(*args, &block)
-    Params.process(*args, &block)
-  end
 end

data/lib/dao/path.rb

@@ -3,7 +3,13 @@ module Dao
     class Error < ::StandardError; end
     class Error::Params < Error; end
 
+  # class methods
+  #
     class << Path
+      def default
+        Path.for(:dao)
+      end
+
       def for(*args)
         new(absolute_path_for(*args))
       end
@@ -21,15 +27,6 @@ module Dao
         ('/' + paths_for(arg, *args).join('/')).squeeze('/')
       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
-
       def params?(string)
         string.to_s =~ %r{/:[^/]+}
       end

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

@@ -9,7 +9,7 @@ Api =
 
 
 
-  ## this is simply a suggest way to model your api.  it is not required.
+  ## this is simply a suggested way to model your api.  it is not required.
   #
     attr_accessor :effective_user
     attr_accessor :real_user

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

@@ -7,5 +7,21 @@ module DaoHelper
       result.error!
     end
   end
+
+  def dao(path, params, mode = nil)
+    unless mode
+      case request.method
+      when "GET"
+        mode = :read
+      when "PUT", "POST", "DELETE"
+        mode = :write
+      else
+        # do nothing - the user must specificy the mode explicity
+      end
+    end
+    result = api.send(mode, path, params)
+    result.route = request.fullpath
+    result
+  end
 end
 ApplicationController.send(:include, DaoHelper)

data/lib/dao/result.rb

@@ -1,151 +1,44 @@
 module Dao
   class Result < ::Map
-    include Dao::InstanceExec
-
-    attr_accessor :api
-    attr_accessor :interface
-    attr_accessor :mode
-    attr_accessor :params
-    attr_accessor :validations
-    attr_accessor :presenter
-    attr_accessor :form
-    attr_accessor :forcing_validity
-
-    def Result.for(*args, &block)
-      new(*args, &block)
-    end
-
     def initialize(*args, &block)
       options = Dao.options_for!(args)
-      args.push('/dao') if args.empty?
-
-      path_args = args.select{|arg| arg.is_a?(String) or args.is_a?(Symbol)}
-      data_args = args.select{|arg| arg.is_a?(Hash)}
-      data_args += [options[:data]] if options.has_key?(:data)
-
-      path = Path.for(*path_args)
-      status = Status.ok
-      errors = Errors.new
-      data = Data.new
 
-      data_args.each do |data_arg|
-        data.update(data_arg)
-      end
-
-      api = options[:api]
-      interface = options[:interface]
-      params = options[:params] || Params.new
-      mode = options[:mode] || (api ? api.mode : Mode.default)
+      self.path = args.shift || options[:path] || Path.default
+      self.route = options[:route] || Route.default
+      self.mode = options[:mode] || Mode.default
+      self.status = options[:status] || Status.default
+      self.errors = options[:errors] || Errors.new
+      self.params = options[:params] || Params.new
+      self.data = options[:data] || Data.new
 
       params.result = self
-      path = interface.path if interface
-
-      form = Form.for(self)
-      validations = Validations.for(self) 
-      presenter = Presenter.for(self) 
-
-      self[:path] = path
-      self[:status] = status
-      self[:mode] = mode
-      self[:errors] = errors
-      self[:data] = data
-
-      @api = api
-      @interface = interface
-      @params = params
-      @form = form
-      @validations = validations
-      @presenter = presenter
-      @forcing_validity = false
-    end
-
-    def path
-      self[:path]
-    end
-
-    def status(*args)
-      self[:status] = Status.for(*args) unless args.empty?
-      self[:status]
-    end
-    def status=(value)
-      status(value)
-    end
-
-    def mode(*args)
-      self[:mode] = Mode.for(*args) unless args.empty?
-      self[:mode]
-    end
-    def mode=(value)
-      mode(value)
-    end
-
-    def errors
-      self[:errors]
-    end
-
-    def data
-      self[:data]
-    end
-
-    def is_valid=(boolean)
-      @is_valid = !!boolean 
-    end
-
-    def is_valid(*bool)
-      @is_valid ||= nil
-      @is_valid = !!bool.first unless bool.empty?
-      @is_valid
-    end
-
-    def valid!
-      @forcing_validity = true
-    end
-
-    def valid?(*args)
-      if @forcing_validity
-        true
-      else
-        options = Dao.options_for!(args)
-        validate unless validations.ran?
-        validate if options[:validate]
-        errors.empty? and status.ok?
-      end
-    end
-
-    def validate(*args, &block)
-      if !args.empty?
-        validations.add(*args, &block)
-      else
-        validations.run
-        status(420) if(status.ok? and !errors.empty?)
-        errors.empty? and status.ok?
-      end
-    end
-
-    def validate!(*args, &block)
-      if !args.empty?
-        validations.add(*args, &block)
-      end
-      @forcing_validity = false
-      validations.run!
-      status(420) if(status.ok? and !errors.empty?)
-      throw(:result, nil) unless(errors.empty? and status.ok?)
-    end
-
-    def validates(*args, &block)
-      validations.add(*args, &block)
+      params.path = self.path
+      params.status = self.status
+      params.errors = self.errors
     end
 
     def error!
       raise Dao::Error::Result.for(self)
     end
 
-    def tag(*args, &block)
-      presenter.tag(*args, &block)
-    end
-
+  # look good for inspect
+  #
     def inspect
       ::JSON.pretty_generate(self, :max_nesting => 0)
     end
+
+  # delegate some methods to the params
+  #
+    Validations::Mixin.list.each do |method|
+      module_eval <<-__, __FILE__, __LINE__
+        def #{ method }(*args)
+          params.send(#{ method.inspect }, *args)
+        end
+      __
+    end
+
+    def form
+      params.form
+    end
   end
 end

data/lib/dao/route.rb

@@ -0,0 +1,87 @@
+module Dao
+  class Route < ::String
+    Default = '/index'.freeze
+
+    class << Route
+      def default
+        Default
+      end
+
+      def like?(route)
+        route.to_s =~ %r{/:[^/]+}
+      end
+
+      def keys_for(route)
+        route = Path.absolute_path_for(route.to_s)
+        route.scan(%r{/:[^/]+}).map{|key| key.sub(%r{^/:}, '')}
+      end
+
+      def pattern_for(route)
+        route = Path.absolute_path_for(route.to_s)
+        re = route.gsub(%r{/:[^/]+}, '/([^/]+)')
+        /#{ re }/ioux
+      end
+
+      def path_for(route, params = {})
+        path = Path.absolute_path_for(route.to_s)
+        params = Map.new(params)
+        params.each do |key, val|
+          re = %r{/:#{ Regexp.escape(key.to_s) }(\Z|/)}
+          repl = "/#{ val.to_s }\\1"
+          path.gsub!(re, repl)
+        end
+        path
+      end
+    end
+
+    attr_accessor :keys
+    attr_accessor :pattern
+
+    def initialize(path)
+      replace(path.to_s)
+      @keys = Route.keys_for(self).freeze
+      @pattern = Route.pattern_for(self).freeze
+      freeze
+    end
+
+    def path
+      self
+    end
+
+    def path_for(params)
+      Route.path_for(self, params)
+    end
+
+    def match(path)
+      match = pattern.match(path).to_a
+    end
+
+    def params_for(path)
+      match = pattern.match(path).to_a
+      if match
+        map = Map.new
+        ignored = match.shift
+        @keys.each_with_index do |key, index|
+          map[key] = match[index]
+        end
+        map
+      end
+    end
+
+    class List < ::Array
+      def add(path)
+        route = Route.new(path)
+        push(route)
+        route
+      end
+
+      def match(name)
+        each do |route|
+          match = route.match(name)
+          return route if match
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/dao/status.rb

@@ -61,13 +61,91 @@ module Dao
       }
     ) unless defined?(Code2Message)
 
-    def Status.underscore(camel_cased_word)
-      camel_cased_word.to_s.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        #gsub(/\s+/, '').
-        tr("-", "_").
-        downcase
+    Groups = ({
+      100 => 'instruction',
+      200 => 'success',
+      300 => 'redirection',
+      400 => 'client_error',
+      500 => 'server_error'
+    }) unless defined?(Groups)
+
+  # class methods
+  #
+    class << Status
+      def list
+        @list ||= Symbol2Code.sort_by{|sym, code| code}.map{|sym, code| send(sym)}
+      end
+
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          #gsub(/\s+/, '').
+          tr("-", "_").
+          downcase
+      end
+
+      def default
+        Status.for(200)
+      end
+
+      def for(*args)
+        if args.size >= 2
+          code = args.shift
+          message = args.join(' ')
+          new(code, message)
+        else
+          arg = args.shift
+          case arg
+            when Result
+              result = arg
+              if arg.errors.nil? or arg.errors.empty? or arg.valid?
+                new(200)
+              else
+                new(500)
+              end
+            when Status
+              arg
+            when Fixnum
+              code = arg
+              message = Code2Message[code]
+              new(code, message)
+            when Symbol, String
+              if arg.to_s =~ %r/^\d+$/
+                code = arg.to_i
+              else
+                sym = Status.underscore(arg).to_sym
+                code = Symbol2Code[sym]
+              end
+              if code
+                message = Code2Message[code]
+              else
+                code = 500
+                message = "Unknown Status #{ arg }"
+              end
+              new(code, message)
+            else
+              if arg.respond_to?(:code) and arg.respond_to?(:message)
+                code, message = arg.code, arg.message
+                new(code, message)
+              else
+                parse(arg)
+              end
+          end
+        end
+      end
+
+      def parse(string)
+        first, last = string.to_s.strip.split(%r/\s+/, 2)
+        if first =~ %r/^\d+$/
+          code = Integer(first)
+          message = last
+        else
+          code = 500
+          message = "Unknown Status #{ string.inspect }"
+        end
+        new(code, message)
+      end
     end
 
     Symbol2Code = (
@@ -80,16 +158,22 @@ module Dao
     Symbol2Code.each do |sym, code|
       module_eval <<-__
         def Status.#{ sym }()
-          @#{ sym } ||= Status.for(:#{ sym })
+          @#{ sym } ||= Status.for(:#{ sym }).freeze
         end
       __
     end
 
+  # instance methods
+  #
     attr :code
     attr :message
     attr :group
 
     def initialize(*args)
+      update(*args)
+    end
+
+    def update(*args)
       code, message =
         if args.size == 2
           [args.first, args.last]
@@ -101,18 +185,10 @@ module Dao
       @group = (@code / 100) * 100
       replace("#{ @code } #{ @message }".strip)
     end
-
-    Groups = ({
-      100 => 'instruction',
-      200 => 'success',
-      300 => 'redirection',
-      400 => 'client_error',
-      500 => 'server_error'
-    }) unless defined?(Groups)
+    alias_method('set', 'update')
 
     Groups.each do |code, group|
       module_eval <<-__, __FILE__, __LINE__ -1
-
         def Status.#{ group }
           @status_group_#{ group } ||= Status.for(#{ code })
         end
@@ -120,23 +196,18 @@ module Dao
         def #{ group }?()
           #{ code } == @group
         end
-
       __
     end
 
-    def Status.list
-      @list ||= Symbol2Code.sort_by{|sym, code| code}.map{|sym, code| send(sym)}
-    end
-
     def good?
       @group < 400
     end
-    alias_method 'ok?', 'good?'
+    alias_method('ok?', 'good?')
 
     def bad?
       @group >= 400
     end
-    alias_method 'error?', 'bad?'
+    alias_method('error?', 'bad?')
 
     def =~(other)
       begin
@@ -163,75 +234,6 @@ module Dao
     def to_json(*args, &block)
       Map[:code, code, :message, message].to_json(*args, &block)
     end
-
-    class << Status
-      def for(*args)
-        if args.size >= 2
-          code = args.shift
-          message = args.join(' ')
-          new(code, message)
-        else
-          arg = args.shift
-          case arg
-            when Result
-              result = arg
-              if arg.errors.nil? or arg.errors.empty? or arg.valid?
-                new(200)
-              else
-                new(500)
-              end
-            when Status
-              arg
-            when Fixnum
-              code = arg
-              message = Code2Message[code]
-              new(code, message)
-            when Symbol, String
-              if arg.to_s =~ %r/^\d+$/
-                code = arg.to_i
-              else
-                sym = Status.underscore(arg).to_sym
-                code = Symbol2Code[sym]
-              end
-              if code
-                message = Code2Message[code]
-              else
-                code = 500
-                message = "Unknown Status #{ arg }"
-              end
-              new(code, message)
-            else
-              if arg.respond_to?(:code) and arg.respond_to?(:message)
-                code, message = arg.code, arg.message
-                new(code, message)
-              else
-                parse(arg)
-              end
-          end
-        end
-      end
-
-      def parse(string)
-        first, last = string.to_s.strip.split(%r/\s+/, 2)
-        if first =~ %r/^\d+$/
-          code = Integer(first)
-          message = last
-        else
-          code = 500
-          message = "Unknown Status #{ string.inspect }"
-        end
-        new(code, message)
-      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
   end
 
   def Dao.status(*args, &block)
@@ -243,8 +245,8 @@ module Dao
   end
 end
 
-__END__
 
+__END__
 
 ### ref: http://en.wikipedia.org/wiki/List_of_HTTP_status_codes