dao 0.0.0 → 2.0.0

data/lib/dao/result.rb

@@ -0,0 +1,87 @@
+module Dao
+  class Result < ::Map
+    attr_accessor :api
+    attr_accessor :endpoint
+    attr_accessor :params
+    attr_accessor :validations
+    attr_accessor :form
+
+    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 = Path.for(*args)
+      status = Status.ok
+      errors = Errors.new
+      data = Data.new
+
+      api = options[:api]
+      endpoint = options[:endpoint]
+      params = options[:params] || Params.new
+
+      path = endpoint.path if endpoint
+
+      form = Form.for(self)
+      validations = Validations.for(self) 
+
+      self[:path] = path
+      self[:status] = status
+      self[:errors] = errors
+      self[:data] = data
+
+      @api = api
+      @endpoint = endpoint
+      @params = params
+      @form = form
+      @validations = validations
+    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 errors
+      self[:errors]
+    end
+
+    def data
+      self[:data]
+    end
+
+    def validates(*args, &block)
+      validations.add(*args, &block)
+    end
+
+    def validate(*args, &block)
+      if !args.empty?
+        validates(*args, &block)
+      else
+        validations.run
+        #status(420) if(status.ok? and !errors.empty?)
+        errors.empty? and status.ok?
+      end
+    end
+
+    def valid?
+      validate
+    end
+
+    def validate!
+      validations.run!
+      #status(420) if(status.ok? and !errors.empty?)
+      throw(:result, nil) unless(errors.empty? and status.ok?)
+    end
+  end
+end

data/lib/dao/slug.rb

@@ -0,0 +1,11 @@
+module Dao
+  class Slug < ::String
+    def Slug.for(*args)
+      string = args.flatten.compact.join('-')
+      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?}
+      new(words.join('-').downcase)
+    end
+  end
+end

data/lib/dao/status.rb

@@ -0,0 +1,223 @@
+module Dao
+  class Status < ::String
+    Code2Message = (
+      {
+        100 => "Continue",
+        101 => "Switching Protocols",
+        102 => "Processing",
+
+        200 => "OK",
+        201 => "Created",
+        202 => "Accepted",
+        203 => "Non-Authoritative Information",
+        204 => "No Content",
+        205 => "Reset Content",
+        206 => "Partial Content",
+        207 => "Multi-Status",
+        226 => "IM Used",
+
+        300 => "Multiple Choices",
+        301 => "Moved Permanently",
+        302 => "Found",
+        303 => "See Other",
+        304 => "Not Modified",
+        305 => "Use Proxy",
+        307 => "Temporary Redirect",
+
+        400 => "Bad Request",
+        401 => "Unauthorized",
+        402 => "Payment Required",
+        403 => "Forbidden",
+        404 => "Not Found",
+        405 => "Method Not Allowed",
+        406 => "Not Acceptable",
+        407 => "Proxy Authentication Required",
+        408 => "Request Timeout",
+        409 => "Conflict",
+        410 => "Gone",
+        411 => "Length Required",
+        412 => "Precondition Failed",
+        413 => "Request Entity Too Large",
+        414 => "Request-URI Too Long",
+        415 => "Unsupported Media Type",
+        416 => "Requested Range Not Satisfiable",
+        417 => "Expectation Failed",
+        420 => "Enhance Your Calm",
+        422 => "Unprocessable Entity",
+        423 => "Locked",
+        424 => "Failed Dependency",
+        426 => "Upgrade Required",
+
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        502 => "Bad Gateway",
+        503 => "Service Unavailable",
+        504 => "Gateway Timeout",
+        505 => "HTTP Version Not Supported",
+        507 => "Insufficient Storage",
+        510 => "Not Extended"
+      }
+    ) 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
+    end
+
+    Symbol2Code = (
+      Code2Message.inject(Hash.new) do |hash, (code, message)|
+        sym = Status.underscore(message.gsub(/\s+/, "")).to_sym
+        hash.update(sym => code)
+      end
+    ) unless defined?(Symbol2Code)
+
+    Symbol2Code.each do |sym, code|
+      module_eval <<-__
+        def Status.#{ sym }()
+          @#{ sym } ||= Status.for(:#{ sym })
+        end
+      __
+    end
+
+    attr :code
+    attr :message
+    attr :group
+
+    def initialize(*args)
+      code, message =
+        if args.size == 2
+          [args.first, args.last]
+        else
+          status = Status.for(args.first || 200)
+          [status.code, status.message]
+        end
+      @code, @message = Integer(code), String(message)
+      @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)
+
+    Groups.each do |code, group|
+      module_eval <<-__
+        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?'
+
+    def bad?
+      @group >= 400
+    end
+    alias_method 'error?', 'bad?'
+
+    def ==(other)
+      begin
+        other = Status.for(other)
+        self.code == other.code and self.message == other.message
+      rescue
+        false
+      end
+    end
+
+    def clone
+      clone = Status.for(code)
+    end
+
+    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
+              sym = Status.underscore(arg).to_sym
+              code = Symbol2Code[sym]
+              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)
+    if args.empty? and block.nil?
+      Status
+    else
+      Status.for(*args, &block)
+    end
+  end
+end

data/lib/dao/stdext.rb

@@ -0,0 +1,10 @@
+class Array
+  def to_dao(*args, &block)
+    Dao.to_dao(self, *args, &block)
+  end
+
+  def as_dao(*args, &block)
+    Dao.as_dao(self, *args, &block)
+  end
+end
+

data/lib/dao/support.rb

@@ -0,0 +1,62 @@
+module Dao
+  def map_for(*args, &block)
+    Map.for(*args, &block)
+  end
+  alias_method(:map, :map_for)
+  alias_method(:hash, :map_for)
+
+  def options_for!(args)
+    Map.options_for!(args)
+  end
+
+  def options_for(args)
+    Map.options_for(args)
+  end
+
+  def db(*args, &block)
+    if args.empty? and block.nil?
+      Db.instance
+    else
+      method = args.shift
+      Db.instance.send(method, *args, &block)
+    end
+  end
+
+  %w( to_dao as_dao ).each do |method|
+
+    module_eval <<-__, __FILE__, __LINE__ - 1
+
+      def #{ method }(object, *args, &block)
+        case object
+          when Array
+            object.map{|element| Dao.#{ method }(element)}
+
+          else
+            if object.respond_to?(:#{ method })
+              object.send(:#{ method }, *args, &block)
+            else
+              object
+            end
+        end
+      end
+
+    __
+  end
+
+
+  def unindent!(s)
+    margin = nil
+    s.each do |line|
+      next if line =~ %r/^\s*$/
+      margin = line[%r/^\s*/] and break
+    end
+    s.gsub! %r/^#{ margin }/, "" if margin
+    margin ? s : nil
+  end
+
+  def unindent(s)
+    s = "#{ s }"
+    unindent!(s)
+    s
+  end
+end

data/lib/dao/validations.rb

@@ -0,0 +1,115 @@
+module Dao
+  class Validations < ::Map
+    class Callback < ::Proc
+      attr :options
+
+      def initialize(options = {}, &block)
+        @options = Dao.map_for(options || {})
+        super(&block)
+      end
+
+      def block
+        self
+      end
+    end
+
+    class << Validations
+      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 errors
+      result.errors
+    end
+
+    def each(&block)
+      depth_first_each(&block)
+    end
+
+    def size
+      size = 0
+      depth_first_each{ size += 1 }
+      size
+    end
+
+    alias_method 'count', 'size'
+    alias_method 'length', 'size'
+
+    Cleared = '___CLEARED___'.freeze unless defined?(Cleared)
+
+    def run
+      previous_errors = []
+      new_errors = []
+
+      errors.each_message do |keys, message|
+        previous_errors.push([keys, message])
+      end
+
+      errors.clear
+
+      depth_first_each do |keys, callback|
+        next unless callback and callback.respond_to?(:to_proc)
+
+        value = params.get(keys)
+        valid = !!callback.call(value)
+        #valid = !!params.instance_exec(value, &callback)
+        message = callback.options[:message] || (value.nil? ? 'is blank.' : 'is invalid.')
+
+        unless valid
+          new_errors.push([keys, message])
+        else
+          new_errors.push([keys, Cleared])
+        end
+      end
+
+      previous_errors.each do |keys, message|
+        errors.add(keys, message) unless new_errors.assoc(keys)
+      end
+
+      new_errors.each do |keys, value|
+        next if value == Cleared
+        message = value
+        errors.add(keys, message)
+      end
+
+      return self
+    end
+
+    def run!
+      errors.clear!
+      run
+    end
+
+    NotNil = lambda{|value| !value.nil?}
+
+    def add(*args, &block)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      block = args.pop if args.last.respond_to?(:call)
+      block ||= NotNil
+      callback = Validations::Callback.new(options, &block)
+      args.push(callback)
+      set(*args)
+    end
+  end
+end