dao 0.0.0 → 2.0.0

data/lib/dao/api/initializers.rb

@@ -0,0 +1,71 @@
+module Dao
+  class Api
+    Initializers = {} unless defined?(Initializers)
+
+    class << Api
+      def new(*args, &block)
+        allocate.instance_eval do
+          before_initializers(*args, &block)
+          initialize(*args, &block)
+          after_initializers(*args, &block)
+          self
+        end
+      end
+
+      def initializers
+        Initializers[self] ||= {:before => [], :after => []}
+      end
+
+      def before_initializers
+        initializers[:before]
+      end
+
+      def before_initializer(&block)
+        method_name = "before_initializer_#{ before_initializers.size }"
+        define_method(method_name, &block)
+        before_initializers.push(method_name)
+      end
+
+      def after_initializers
+        initializers[:after]
+      end
+
+      def after_initializer(&block)
+        after_initializers.push(block)
+      end
+
+      def superclasses
+        @superclasses ||= ancestors.select{|ancestor| ancestor <= Dao::Api}
+      end
+    end
+
+    def superclasses
+      @superclasses ||= self.class.superclasses
+    end
+
+    def run_initializers(which, *args, &block)
+      superclasses.each do |superclass|
+        superclass.send("#{ which }_initializers").each do |method_name|
+          send(method_name, *args, &block)
+        end
+      end
+      send("#{ which }_initialize", *args, &block)
+    end
+
+    def before_initializers(*args, &block)
+      run_initializers(:before, *args, &block)
+    end
+
+    def after_initializers(*args, &block)
+      run_initializers(:after, *args, &block)
+    end
+
+    def before_initialize(*args, &block)
+      :hook
+    end
+
+    def after_initialize(*args, &block)
+      :hook
+    end
+  end
+end

data/lib/dao/api/modes.rb

@@ -0,0 +1,85 @@
+
+module Dao
+  class Api
+    class << Api
+      def modes(*modes)
+        @modes ||= []
+        modes.flatten.compact.map{|mode| Api.add_mode(mode)} unless modes.empty?
+        @modes
+      end
+
+      def modes=(*modes)
+        modes(*modes)
+      end
+
+      def add_mode(mode)
+        modes.push(mode = Mode.for(mode)).uniq!
+
+        module_eval(<<-__, __FILE__, __LINE__ - 1)
+
+          def #{ mode }(*args, &block)
+            if args.empty?
+              mode(#{ mode.inspect }, &block)
+            else
+              mode(#{ mode.inspect }) do
+                call(*args, &block)
+              end
+            end
+          end
+
+          def #{ mode }?(&block)
+            mode?(#{ mode.inspect }, &block)
+          end
+
+        __
+
+        mode
+      end
+    end
+
+    def mode=(mode)
+      @mode = Mode.for(mode)
+    end
+
+    def mode(*args, &block)
+      @mode ||= Mode.default
+
+      if args.empty? and block.nil?
+        @mode
+      else
+        if block
+          mode = self.mode
+          self.mode = args.shift
+          begin
+            return(instance_eval(&block))
+          ensure
+            self.mode = mode
+          end
+        else
+          self.mode = args.shift
+          return(self)
+        end
+      end
+    end
+
+    def mode?(mode, &block)
+      condition = self.mode == mode
+
+      if block.nil?
+        condition
+      else
+        if condition
+          result = block.call
+          throw(:result, result) if catching_the_result?
+          result
+        end
+      end
+    end
+  end
+
+  Api.modes = Mode.list
+
+  Api.before_initializer do |*args|
+    @mode = Mode.default
+  end
+end

data/lib/dao/blankslate.rb

@@ -0,0 +1,5 @@
+module Dao
+  class BlankSlate
+    instance_methods.each{|m| undef_method(m) unless m.to_s =~ /(^__)|object_id/}
+  end
+end

data/lib/dao/data.rb

@@ -0,0 +1,58 @@
+module Dao
+  class Data < ::Map
+    add_conversion_method!(:to_dao)
+    add_conversion_method!(:as_dao)
+  end
+end
+
+
+=begin
+    %w( to_dao as_dao ).each do |method|
+      module_eval <<-__, __FILE__, __LINE__
+        def #{ method }(object, *args, &block)
+          case object
+            when Array
+              object.map{|element| Data.#{ method }(element)}
+
+            else
+              if object.respond_to?(:#{ method })
+                object.send(:#{ method }, *args, &block)
+              else
+                object
+              end
+          end
+        end
+      __
+    end
+=end
+
+=begin
+    IdKeys =
+      %w( id uuid guid ).map{|key| [key, key.to_sym, "_#{ key }", "_#{ key }".to_sym]}.flatten
+
+    def id
+      IdKeys.each{|key| return self[key] if has_key?(key)}
+      return nil
+    end
+
+    def has_id?
+      IdKeys.each{|key| return true if has_key?(key)}
+      return false
+    end
+
+    def new?
+      !has_id?
+    end
+
+    def new_record?
+      !has_id?
+    end
+
+    def model_name
+      path.to_s
+    end
+
+    def slug
+      Slug.for(path)
+    end
+=end

data/lib/dao/db.rb

@@ -0,0 +1,183 @@
+require 'yaml'
+require 'yaml/store'
+require 'fileutils'
+
+module Dao
+  class Db
+    attr_accessor :path
+
+    def initialize(*args)
+      options = Dao.options_for!(args)
+      @path = (args.shift || options[:path] || './db/dao.yml').to_s
+      FileUtils.mkdir_p(File.dirname(@path)) rescue nil
+    end
+
+    def db
+      self
+    end
+
+    def ystore
+      @ystore ||= YAML::Store.new(path)
+    end
+
+    class Collection
+      def initialize(name, db)
+        @name = name.to_s
+        @db = db
+      end
+
+      def save(data = {})
+        @db.save(@name, data)
+      end
+      alias_method(:create, :save)
+      alias_method(:update, :save)
+
+      def find(id = :all)
+        @db.find(@name, id)
+      end
+
+      def all
+        find(:all)
+      end
+
+      def [](id)
+        find(id)
+      end
+
+      def delete(id)
+        @db.delete(@name, id)
+      end
+
+      def to_hash
+        transaction{|y| y[@name]}
+      end
+
+      def to_yaml(*args, &block)
+        Hash.new.update(to_hash).to_yaml(*args, &block)
+      end
+
+      def transaction(*args, &block)
+        @db.ystore.transaction(*args, &block)
+      end
+    end
+
+    def [](name)
+      Collection.new(name, db)
+    end
+
+    def transaction(*args, &block)
+      ystore.transaction(*args, &block)
+    end
+
+    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]
+      end
+    end
+
+    def data_for(data)
+      data ? Map.for(data) : nil
+    end
+
+    alias_method(:create, :save)
+
+    def find(collection, id = :all, &block)
+      ystore.transaction do |y|
+        collection = (y[collection.to_s] ||= {})
+        if id.nil? or id == :all
+          list = collection.values.map{|data| data_for(data)}
+          if block
+            collection[:all] = list.map{|record| data_for(block.call(record))}
+          else
+            list
+          end
+        else
+          key = String(id)
+          record = data_for(collection[key])
+          if block
+            collection[key] = data_for(block.call(record))
+          else
+            record
+          end
+        end
+      end
+    end
+
+    def update(collection, id = :all, updates = {})
+      data = data_for(data)
+      find(collection, id) do |record|
+        record.update(updates)
+      end
+    end
+
+    def delete(collection, id = :all)
+      ystore.transaction do |y|
+        collection = (y[collection.to_s] ||= {})
+        if id.nil? or id == :all
+          collection.clear()
+        else
+          deleted = collection.delete(String(id))
+          data_for(deleted) if deleted
+        end
+      end
+    end
+
+    def next_id_for(collection, data)
+      data = data_for(data)
+      begin
+        id = id_for(data)
+        raise if id.strip.empty?
+        id
+      rescue
+        data['id'] = String(collection.size + 1)
+        id_for(data)
+      end
+    end
+
+    def id_for(data)
+      data = data_for(data)
+      %w( id _id ).each{|key| return String(data[key]) if data.has_key?(key)}
+      raise("no id discoverable for #{ data.inspect }")
+    end
+
+    def to_hash
+      ystore.transaction do |y|
+        y.roots.inject(Hash.new){|h,k| h.update(k => y[k])}
+      end
+    end
+
+    def to_yaml(*args, &block)
+      to_hash.to_yaml(*args, &block)
+    end
+
+    class << Db
+      attr_writer :root
+      attr_writer :instance
+
+      def default_root()
+        defined?(Rails.root) ? File.join(Rails.root.to_s, 'db') : './db'
+      end
+
+      def default_path()
+        File.join(default_root, 'dao.yml')
+      end
+
+      def method_missing(method, *args, &block)
+        super unless instance.respond_to?(method)
+        instance.send(method, *args, &block)
+      end
+
+      def instance
+        @instance ||= Db.new(Db.default_path)
+      end
+
+      def root
+        @root ||= default_root
+      end
+    end
+  end
+end

data/lib/dao/endpoint.rb

@@ -0,0 +1,16 @@
+module Dao
+  class Endpoint
+    Attrs = %w( api path method 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
+  end
+end

data/lib/dao/engine.rb

@@ -0,0 +1,7 @@
+module Dao
+  if(defined?(Rails) && Rails::VERSION::MAJOR == 3)
+    class Engine < Rails::Engine
+      engine_name :dao
+    end
+  end
+end

data/lib/dao/errors.rb

@@ -0,0 +1,238 @@
+module Dao
+  class Errors < ::Map
+    Global = '*' unless defined?(Global)
+    Separator = ':' unless defined?(Separator)
+
+    class Message < ::String
+      attr_accessor :sticky
+
+      def initialize(*args)
+        options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+        replace(args.join(' '))
+        @sticky = options[:sticky]
+      end
+
+      def sticky?
+        @sticky ||= nil
+        !!@sticky
+      end
+    end
+
+    class << Errors
+      def global_key
+        [Global]
+      end
+
+      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
+
+    def add(*args)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      sticky = options[:sticky]
+      clear = options[:clear]
+
+      args.flatten!
+      message = args.pop
+      keys = args
+      keys = [Global] if keys.empty?
+      errors = Hash.new
+
+      if Array(keys) == [Global]
+        sticky = true unless options.has_key?(:sticky)
+      end
+
+      sticky = true if(message.respond_to?(:sticky?) and message.sticky?)
+
+      if message
+        if message.respond_to?(:full_messages)
+          message.depth_first_each do |keys, msg|
+            errors[keys] = Message.new(msg, :sticky => sticky)
+          end
+        else
+          errors[keys] = Message.new(message, :sticky => sticky)
+        end
+      end
+
+      result = []
+
+      errors.each do |keys, message|
+        list = get(keys)
+        unless get(keys)
+          set(keys => [])
+          list = get(keys)
+        end
+        list.clear if clear
+        list.push(message)
+        result = list
+      end
+      
+      result
+    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 add!(*args)
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options[:sticky] = true
+      args.push(options)
+      add(*args)
+    end
+    alias_method 'add_to_base!', 'add!'
+
+    alias_method 'clear!', 'clear' unless instance_methods.include?('clear!')
+
+    def update(other, options = {})
+      options = Dao.map_for(options)
+      prefix = Array(options[:prefix]).flatten.compact
+
+      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
+
+    def clear
+      keep = []
+      depth_first_each do |keys, message|
+        index = keys.pop
+        args = [keys, message].flatten
+        keep.push(args) if message.sticky?
+      end
+      clear!
+    ensure
+      keep.each{|args| add!(*args)}
+    end
+
+    def invalid?(*keys)
+      !get(keys).nil?
+    end
+
+    alias_method 'on?', 'invalid?'
+
+    alias_method 'on', 'get'
+
+    def size
+      size = 0
+      depth_first_each{ size += 1 }
+      size
+    end
+
+    alias_method 'count', 'size'
+    alias_method 'length', 'size'
+
+    def full_messages
+      full_messages = []
+
+      depth_first_each do |keys, value|
+        index = keys.pop
+        key = keys.join('.')
+        value = value.to_s
+        next if value.strip.empty?
+        full_messages.push([key, value])
+      end
+
+      full_messages.sort! do |a,b|
+        a, b = a.first, b.first
+        if a == Global
+          b == Global ? 0 : -1
+        elsif b == Global
+          a == Global ? 0 : 1
+        else
+          a <=> b
+        end
+      end
+
+      full_messages
+    end
+
+    def each_message
+      depth_first_each do |keys, message|
+        index = keys.pop
+        message = message.to_s.strip
+        next if message.empty?
+        yield(keys, message)
+      end
+    end
+
+    def each_full_message
+      full_messages.each{|msg| yield msg}
+    end
+
+    alias_method 'each_full', 'each_full_message'
+
+    def messages
+      messages =
+        (self[Global]||[]).map{|message| message}.
+        select{|message| not message.strip.empty?}
+    end
+
+    def to_html(*args)
+      Errors.to_html(errors=self, *args)
+    end
+
+    def Errors.to_html(*args, &block)
+      if block
+        define_method(:to_html, &block)
+      else
+        default_errors_to_html(*args)
+      end
+    end
+
+    def Errors.default_errors_to_html(*args)
+      error = args.shift
+      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      errors = [error, *args].flatten.compact
+
+      at_least_one = false
+      css_class = options[:class] || 'dao errors'
+
+      html = []
+
+      html.push("<table class='#{ css_class }'>")
+      html.push("<caption>Sorry, there were some errors.</caption>")
+        errors.each do |e|
+          e.full_messages.each do |key, value|
+            at_least_one = true
+            key = key.to_s
+            html.push("<tr class='field'>")
+              html.push("<td class='field'>#{ key }</td>")
+              html.push("<td class='separator'>#{ Separator }</td>")
+              html.push("<td class='message'>#{ value }</td>")
+            html.push("</tr>")
+          end
+        end
+      html.push("</table>")
+
+      at_least_one ? html.join("\n") : ''
+    end
+
+    def to_s(*args, &block)
+      to_html(*args, &block)
+    end
+  end
+end