dao 3.3.0 → 4.2.1

data/db/dao.yml

@@ -1,5 +0,0 @@
---- 
-foo: 
-  "1": 
-    id: 1
-    bar: 44

data/lib/dao/api/interfaces.rb

@@ -1,306 +0,0 @@
-module Dao
-  class Api
-  # class methods
-  #
-    class << Api
-      def unload!
-        state.clear
-      end
-
-      def state
-        @state ||= {
-          :interfaces => {},
-          :blocks => {},
-          :README => [],
-          :docs => []
-        }
-      end
-
-      def interface(path, &block)
-        api = self
-        path = Path.new(path)
-
-        route = routes.add(path) if Route.like?(path)
-
-        interface = Interface.new({
-          'api' => api,
-          'path' => path,
-          'route' => route,
-          'block' => block,
-          'doc' => docs.pop
-        })
-
-        interfaces[path] = interface
-      end
-      alias_method('call', 'interface')
-
-      def interfaces
-        state[:interfaces]
-      end
-
-      def description(*args)
-        doc(:description => lines_for(*args))
-      end
-      alias_method('desc', 'description')
-
-      def doc(*args)
-        docs.push(Map[:description, nil]) if docs.empty?
-        doc = docs.last
-        options = Dao.options_for!(args)
-        if options.empty?
-          options[:description] = lines_for(*args)
-        end
-        doc.update(options)
-        doc
-      end
-
-      def docs
-        state[:docs]
-      end
-
-      def readme(*args)
-        if args.empty?
-          state[:README]
-        else
-          state[:README] = lines_for(args)
-        end
-      end
-      alias_method('README', 'readme')
-
-      def lines_for(*args)
-        Dao.unindent(args.flatten.compact.join("\n")).split(/\n/)
-      end
-
-      def readme=(readme)
-        self.readme = readme.to_s
-      end
-
-      def index
-        index = Map.new
-        index[:README] = readme
-        interfaces.each do |path, interface|
-          index[path] = interface.doc || {'description' => ''}
-        end
-        index
-      end
-    end
-
-# instance methods
-#
-
-
-  # call support 
-  #
-    def call(path = '/index', params = {}, options = {})
-      api = self
-      path = Path.new(path)
-      interface = interfaces[path]  ### interfaces.by_path(path)
-      route = nil
-
-      unless interface
-        route = route_for(path)
-        interface = interfaces[route]
-      end
-
-      unless interface
-        return index if path == '/index'
-        raise(NameError, "NO SUCH INTERFACE: #{ path }")
-      end
-
-      if route
-        params.update(route.params_for(path))
-        path = route.path_for(params)
-      else
-        if Route.like?(path)
-          route = Route.new(path)
-          path = route.path_for(params)
-        else
-          route = path
-        end
-      end
-
-      context = Context.for(api, route, path, interface, params, options)
-
-      callstack(context) do
-        catching(:result) do
-          context.call()
-        end
-      end
-
-      context.result
-    end
-
-  # lookup a route
-  #
-    def route_for(*args)
-      self.class.routes.match(*args)
-    end
-
-  # context support
-  #
-    def callstack(context = nil, &block)
-      @callstack ||= []
-
-      if block and context
-        begin
-          @callstack.push(context)
-          return block.call()
-        ensure
-          @callstack.pop
-        end
-      else
-        @callstack
-      end
-    end
-
-    def context
-      callstack.last || raise('no context!')
-    end
-
-    def context?
-      !!callstack.last
-    end
-
-    def catching(label = :result, &block)
-      @catching ||= []
-
-      if block
-        begin
-          @catching.push(label)
-          catch(label, &block)
-        ensure
-          @catching.pop
-        end
-      else
-        @catching.last
-      end
-    end
-
-    def return!(*value)
-      throw(:result, *value)
-    end
-
-    def catching_results(&block)
-      catching(:result, &block)
-    end
-
-    def catching?
-      catching
-    end
-
-    def catching_results?
-      catching == :result
-    end
-
-  # delgate some methods to the context
-  #
-    Context.attrs.each do |method|
-      module_eval <<-__, __FILE__, __LINE__
-        def #{ method }(*args)
-          context.send(#{ method.inspect }, *args)
-        end
-      __
-    end
-
-    def status(*args)
-      context.status.update(*args) unless args.empty?
-      context.status
-    end
-    def status!(*args)
-      status.update(*args)
-      return!
-    end
-
-    def data(*args)
-      context.data.replace(*args) unless args.empty?
-      context.data
-    end
-    def data!(*args)
-      data(*args)
-      valid!
-    end
-
-    def params!(*args)
-      params.replace(*args)
-      valid!
-    end
-
-    def error!
-      result.error!
-    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
-
-  # misc
-  #
-    def index
-      self.class.index
-    end
-
-    def interfaces
-      self.class.interfaces
-    end
-
-    def respond_to?(*args)
-      super(*args) || super(Path.absolute_path_for(*args))
-    end
-
-  # immediate parameter parsing support
-  #
-    def parameter(*args, &block)
-      options = Map.options_for!(args)
-
-      keys = args + Array(options[:keys]) + Array(options[:or])
-
-      raise(ArgumentError, 'no keys') if keys.empty?
-
-      blank = Object.new.freeze
-      value = blank
-
-      keys.each do |key|
-        if params.has?(key)
-          value = params.get(key)
-          break unless value.to_s.strip.empty?
-        end
-      end
-
-      if value == blank
-        message =
-          case options[:error]
-            when nil, false
-              nil
-            when true
-              which = keys.map{|key| Array(key).join('.')}.join(' or ')
-              "#{ which } (parameter is blank)"
-            else
-              message = options[:error].to_s
-          end
-        errors.add(message) if message
-
-        status(options[:status]) if options[:status]
-        return! if options[:return!]
-      end
-
-      value == blank ? nil : value
-    end
-    alias_method('param', 'parameter')
-
-    def parameter!(*args, &block)
-      options = args.last.is_a?(Hash) ? Map.for(args.pop) : Map.new
-      args.push(options)
-      options[:error] = true unless options.has_key?(:error)
-      options[:return!] = true unless options.has_key?(:return!)
-      options[:status] = 412 unless options.has_key?(:status)
-      parameter(*args, &block)
-    end
-    alias_method('param!', 'parameter!')
-  end
-end

data/lib/dao/interface.rb

@@ -1,28 +0,0 @@
-module Dao
-  class Interface
-    Attrs = %w( api path route block doc )
-    Attrs.each{|attr| attr_accessor(attr)}
-
-    def initialize(options = {})
-      update(options)
-    end
-
-    def update(options = {})
-      options.each do |key, val|
-        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/presenter.rb

@@ -1,129 +0,0 @@
-module Dao
-  class Presenter
-    include Tagz.globally
-
-    class << Presenter 
-      def for(*args, &block)
-        new(*args, &block)
-      end
-    end
-
-    attr_accessor :result
-    attr_accessor :formats
-
-    def initialize(*args, &block)
-      @result = args.shift if args.first.is_a?(Result)
-      @formats = Map.new
-    end
-
-    %w( set get has has? [] ).each do |method|
-      module_eval <<-__, __FILE__, __LINE__
-        def #{ method }(*args, &block)
-          data.#{ method }(*args, &block)
-        end
-      __
-    end
-
-    def extend(*args, &block)
-      return super if block.nil?
-      singleton_class =
-        class << self
-          self
-        end
-      singleton_class.module_eval(&block)
-    end
-
-    def tag(*args, &block)
-      options = Dao.options_for!(args)
-      args.push(:div) if args.empty?
-      tagname = args.shift
-      keys = args
-
-      tag_method = "#{ tagname }_"
-
-      id = options.delete(:id) || id_for(keys)
-      klass = class_for(keys, options.delete(:class))
-      error = error_for(keys, options.delete(:error))
-
-      tag_options =
-        options_for(options, :id => id, :class => klass, :data_error => error)
-
-      value = value_for(keys)
-      tag_value = instance_exec(value, &format_for(keys))
-
-      send(tag_method, tag_options){ tag_value }
-    end
-
-    include InstanceExec
-
-    DefaultFormat = lambda{|value| value}
-
-    def format_for(keys)
-      formats.get(keys) || DefaultFormat
-    end
-
-    def format(list_of_keys, &block)
-      Array(list_of_keys).each do |keys|
-        formats.set(keys, block)
-      end
-    end
-
-    def data
-      result.data
-    end
-
-    def errors
-      result.errors
-    end
-
-    def ==(other)
-      result == other.result
-    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(keys)
-      return nil unless data.has?(keys)
-      value = Tagz.escapeHTML(data.get(keys))
-    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