dao 4.2.1 → 4.4.2

data/lib/dao/result.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Result < ::Map
     def initialize(*args, &block)
@@ -12,8 +13,56 @@ module Dao
       self.data = options[:data] || Data.new
     end
 
+=begin
+    %w(
+      path
+      route
+      mode
+      status
+      params
+      errors
+      data
+    ).each do |attr|
+
+      module_eval <<-__, __FILE__, __LINE__
+        def #{ attr }(*value)
+          unless value.empty?
+            self["#{ attr }"] = value.first
+          end
+          self["#{ attr }"]
+        end
+
+        def #{ attr }=(value)
+          self["#{ attr }"] = value
+        end
+      __
+
+    end
+
+    def name
+      path
+    end
+
+    def attributes
+      params
+    end
+=end
+
+
+    def form
+      @form ||= (
+        Form.new.tap do |f|
+          f.object = self
+          f.attributes = params
+          f.errors = errors
+          f.status = status
+          f.name = path
+        end
+      )
+    end
+
     def inspect
-      ::JSON.pretty_generate(self, :max_nesting => 0)
+      Dao.json_for(self)
     end
   end
 end

data/lib/dao/route.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Route < ::String
     Default = '/index'.freeze

data/lib/dao/slug.rb

@@ -1,40 +1,16 @@
-begin
-  require 'rubygems'
-rescue LoadError
-end
-
-begin
-  require 'unidecode'
-rescue LoadError
-end
-
-class Slug < ::String
-  Slug::Version = '0.0.1'
-
-  def Slug.version
-    '0.0.1'
-  end
-
-  Join = '-'
+# -*- encoding : utf-8 -*-
+module Dao
+  class Slug < ::String
+    Join = '-'
 
-  def Slug.for(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    join = options[:join]||options['join']||Join
-    string = args.flatten.compact.join(join)
-    string = unidecode(string)
-    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(join).downcase)
-  end
-
-  unless defined?(Unidecoder)
-    def Slug.unidecode(string)
-      string
-    end
-  else
-    def Slug.unidecode(string)
-      Unidecoder.decode(string)
+    def Slug.for(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      join = options[:join]||options['join']||Join
+      string = args.flatten.compact.join(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(join).downcase)
     end
   end
 end

data/lib/dao/status.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   class Status < ::String
   ## http://en.wikipedia.org/wiki/List_of_HTTP_status_codes
@@ -57,7 +58,84 @@ module Dao
         504 => "Gateway Timeout",
         505 => "HTTP Version Not Supported",
         507 => "Insufficient Storage",
-        510 => "Not Extended"
+        510 => "Not Extended",
+
+
+      ### ref: https://github.com/joho/7XX-rfc
+
+      #70X => "Inexcusable",
+        701 => "Meh",
+        702 => "Emacs",
+
+      #71X => "Novelty Implementations",
+        710 => "PHP",
+        711 => "Convenience Store",
+        719 => "I am not a teapot",
+
+      #72X => "Edge Cases",
+        720 => "Unpossible",
+        721 => "Known Unknowns",
+        722 => "Unknown Unknowns",
+        723 => "Tricky",
+        724 => "This line should be unreachable",
+        725 => "It works on my machine",
+        726 => "It's a feature, not a bug",
+
+      #73X => "Fucking",
+        731 => "Fucking Rubygems",
+        732 => "Fucking Unicode",
+        733 => "Fucking Deadlocks",
+        734 => "Fucking Deferreds",
+        735 => "Fucking IE",
+        736 => "Fucking Race Conditions",
+        737 => "FuckThreadsing",
+        738 => "Fucking Bundler",
+        739 => "Fucking Windows",
+
+      #74X => "Meme Driven",
+        741 => "Compiling",
+        742 => "A kitten dies",
+        743 => "I thought I knew regular expressions",
+        744 => "Y U NO write integration tests?",
+        745 => "I don't always test my code, but when I do I do it in production",
+        746 => "Missed Ballmer Peak",
+        747 => "Motherfucking Snakes on the Motherfucking Plane",
+        748 => "Confounded by Ponies",
+        749 => "Reserved for Chuck Norris",
+
+      #75X => "Syntax Errors",
+        750 => "Didn't bother to compile it",
+        753 => "Syntax Error",
+
+      #76X => "Substance-Affected Developer",
+        761 => "Hungover",
+        762 => "Stoned",
+        763 => "Under-Caffeinated",
+        764 => "Over-Caffeinated",
+        765 => "Railscamp",
+        766 => "Sober",
+        767 => "Drunk",
+
+      #77X => "Predictable Problems",
+        771 => "Cached for too long",
+        772 => "Not cached long enough",
+        773 => "Not cached at all",
+        774 => "Why was this cached?",
+        776 => "Error on the Exception",
+        777 => "Coincidence",
+        778 => "Off By One Error",
+        779 => "Off By Too Many To Count Error",
+
+      #78X => "Somebody Else's Problem",
+        781 => "Operations",
+        782 => "QA",
+        783 => "It was a customer request, honestly",
+        784 => "Management, obviously",
+        785 => "TPS Cover Sheet not attached",
+
+      #79X => "Internet crashed",
+        797 => "This is the last page of the Internet. Go back",
+        799 => "End of the world"
       }
     ) unless defined?(Code2Message)
 
@@ -66,7 +144,8 @@ module Dao
       200 => 'success',
       300 => 'redirection',
       400 => 'client_error',
-      500 => 'server_error'
+      500 => 'server_error',
+      700 => 'developer_error'
     }) unless defined?(Groups)
 
   # class methods
@@ -78,10 +157,14 @@ module Dao
 
       def underscore(camel_cased_word)
         camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/\s+/, '_').
           gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
           gsub(/([a-z\d])([A-Z])/,'\1_\2').
-          #gsub(/\s+/, '').
+          gsub(/[^A-Za-z0-9_]/, '_').
           tr("-", "_").
+          squeeze('_').
+          gsub(/^_+/, '').
+          gsub(/_+$/, '').
           downcase
       end
 
@@ -150,7 +233,7 @@ module Dao
 
     Symbol2Code = (
       Code2Message.inject(Hash.new) do |hash, (code, message)|
-        sym = Status.underscore(message.gsub(/\s+/, "")).to_sym
+        sym = Status.underscore(message.gsub(/\s+/, "_")).to_sym
         hash.update(sym => code)
       end
     ) unless defined?(Symbol2Code)
@@ -165,9 +248,10 @@ module Dao
 
   # instance methods
   #
-    attr :code
-    attr :message
-    attr :group
+    attr_accessor :code
+    attr_accessor :message
+    attr_accessor :group
+    attr_accessor :source
 
     def initialize(*args)
       update(*args)

data/lib/dao/stdext.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class Array
   def to_dao(*args, &block)
     Dao.to_dao(self, *args, &block)

data/lib/dao/support.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Dao
   def map_for(*args, &block)
     Map.for(*args, &block)
@@ -66,42 +67,29 @@ module Dao
     Form.name_for(path, *keys)
   end
 
-  def parse(*args, &block)
-    Params.process(*args, &block)
-  end
-
-  def normalize_parameters(params)
-    Params.normalize_parameters(params)
-  end
-
   def current
-    @current ||=
-      Map.new(
-        :controller => nil
-      )
+    Current
   end
 
   def current_controller(*args)
-    current.controller = args.first unless args.empty?
-    current.controller || mock_controller
+    Current.controller = args.first unless args.empty?
+    Current.controller
   end
   alias_method('controller', 'current_controller')
 
   def current_controller=(controller)
-    current.controller = controller
+    Current.controller = controller
   end
   alias_method('controller=', 'current_controller=')
 
+  def mock_controller
+    Current.mock_controller
+  end
+
   %w( request response session ).each do |attr|
     module_eval <<-__, __FILE__, __LINE__
       def current_#{ attr }
-        @current_#{ attr } ||= current_controller.instance_eval{ #{ attr } }
-      end
-      def current_#{ attr }=(value)
-        @current_#{ attr } = value
-      end
-      def #{ attr }
-        current_#{ attr }
+        current_controller.instance_eval{ #{ attr } }
       end
     __
   end
@@ -109,7 +97,7 @@ module Dao
   %w( current_user effective_user real_user ).each do |attr|
     module_eval <<-__, __FILE__, __LINE__
       def #{ attr }
-        @#{ attr } ||= current_controller.instance_eval{ #{ attr } }
+        current_controller.instance_eval{ #{ attr } }
       end
     __
   end
@@ -122,58 +110,13 @@ module Dao
     end
   end
 
-  def key_for(*keys)
-    key = keys.flatten.join('.').strip
-    key.split(%r/\s*[,.:_-]\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
-  end
-
-  def mock_controller
-    ensure_rails_application do
-      require 'action_dispatch/testing/test_request.rb'
-      require 'action_dispatch/testing/test_response.rb'
-      store = ActiveSupport::Cache::MemoryStore.new
-      controller = 
-        begin
-          ApplicationController.new
-        rescue NameError
-          ActionController::Base.new
-        end
-      controller.perform_caching = true
-      controller.cache_store = store
-      request = ActionDispatch::TestRequest.new
-      response = ActionDispatch::TestResponse.new
-      controller.request = request
-      controller.response = response
-      controller.send(:initialize_template_class, response)
-      controller.send(:assign_shortcuts, request, response)
-      controller.send(:default_url_options).merge!(DefaultUrlOptions) if defined?(DefaultUrlOptions)
-      controller
-    end
-  end
-
-  def ensure_rails_application(&block)
-    if Rails.application.nil?
-      mock = Class.new(Rails::Application)
-      Rails.application = mock.instance
-      begin
-        block.call()
-      ensure
-        Rails.application = nil
-      end
-    else
-      block.call()
-    end
-  end
-
   def normalize_parameters(params)
     dao = (params.delete('dao') || {}).merge(params.delete(:dao) || {})
 
-    unless dao.blank?
+    unless dao.empty?
       dao.each do |key, paths_and_values|
-        params[key] = nil
         next if paths_and_values.blank?
-
-        map = Map.new
+        map = Map.for(params[key])
 
         paths_and_values.each do |path, value|
           keys = keys_for(path)
@@ -182,16 +125,25 @@ module Dao
 
         params[key] = map
       end
+
+      params['dao'] = dao
     end
 
-    #params[:dao] = {:normalized => true}
     params
   end
 
-  def keys_for(keys)
-    keys.strip.split(%r/\s*[,._-]\s*/).map{|key| key =~ %r/^\d+$/ ? Integer(key) : key}
+  def keys_for(*keys)
+    keys = keys.join('.').scan(/[^\,\.\s]+/iomx)
+    
+    keys.map do |key|
+      digity, stringy, digits = %r/^(~)?(\d+)$/iomx.match(key).to_a
+
+      digity ? stringy ? String(digits) : Integer(digits) : key
+    end
   end
 
+  alias_method(:key_for, :keys_for)
+
   def render_json(object, options = {})
     options = options.to_options!
     controller = options[:controller] || Dao.current_controller
@@ -210,18 +162,76 @@ module Dao
     end
   end
 
-  def json_for(object)
+  def json_for(object, options = {})
     object = object.as_json if object.respond_to?(:as_json)
 
+    options = options.empty? ? Map.for(options) : options
+    options[:pretty] = json_pretty?  unless options.has_key?(:pretty)
+
     begin
-      if Rails.env.production?
-        ::JSON.generate(object)
-      else
-        ::JSON.pretty_generate(object, :max_nesting => 0)
-      end
+      MultiJson.dump(object, options)
     rescue Object => e
-      Rails.logger.error(e)
       YAML.load( object.to_yaml ).to_json
     end
   end
+
+  def json_pretty?
+    @json_pretty ||= (defined?(Rails) ? !Rails.env.production? : true)
+  end
+
+  def call(object, method, *args, &block)
+    args = Dao.args_for_arity(args, object.method(method).arity)
+    object.send(method, *args, &block)
+  end
+
+  def args_for_arity(args, arity)
+    arity = Integer(arity.respond_to?(:arity) ? arity.arity : arity)
+    arity < 0 ? args.dup : args.slice(0, arity)
+  end
+
+  def tree_walk(node, *path, &block)
+    iterator = Array === node ? :each_with_index : :each
+
+    node.send(iterator) do |key, val|
+      key, val = val, key if Array === node
+      path.push(key)
+      begin
+        caught =
+          catch(:tree_walk) do
+            block.call(path, val)
+            nil
+          end
+        next if caught==:next_sibling
+
+        case val
+          when Hash, Array
+            tree_walk(val, *path, &block)
+        end
+      ensure
+        path.pop
+      end
+    end
+  end
+
+
+  {
+    'ffi-uuid'  => proc{|*args| FFI::UUID.generate_time.to_s},
+    'uuidtools' => proc{|*args| UUIDTools::UUID.timestamp_create.to_s},
+    'uuid'      => proc{|*args| UUID.generate.to_s},
+  }.each do |lib, implementation|
+    begin
+      require(lib)
+      define_method(:uuid, &implementation)
+      break
+    rescue LoadError
+      nil
+    end
+  end
+  abort 'no suitable uuid generation library detected' unless method_defined?(:uuid)
+
+  def ensure_interface!(object, *interface)
+    interface.flatten.compact.each do |method|
+      raise(NotImplementedError, "#{ object.class.name }##{ method }") unless object.respond_to?(method)
+    end
+  end
 end