dao 5.5.0 → 8.0.0

data/lib/dao/_lib.rb

@@ -0,0 +1,42 @@
+module Dao
+  Version = '8.0.0' unless defined?(Version)
+
+  def version
+    Dao::Version
+  end
+
+  def dependencies
+    {
+      'rails'             => [ 'rails'             , ' ~> 6.0'  ] ,
+      'map'               => [ 'map'               , ' ~> 6.6'  ] ,
+      'fattr'             => [ 'fattr'             , ' ~> 2.4'  ] ,
+      'tagz'              => [ 'tagz'              , ' ~> 9.10' ] ,
+      'rails_current'     => [ 'rails_current'     , ' ~> 2.2'  ] ,
+    }
+  end
+
+  def description
+    "presenter, conductor, api, and better form objects for you rails' pleasure"
+  end
+
+  def libdir(*args, &block)
+    @libdir ||= File.dirname(File.expand_path(__FILE__).sub(/\.rb$/,''))
+    args.empty? ? @libdir : File.join(@libdir, *args)
+  ensure
+    if block
+      begin
+        $LOAD_PATH.unshift(@libdir)
+        block.call()
+      ensure
+        $LOAD_PATH.shift()
+      end
+    end
+  end
+
+  def load(*libs)
+    libs = libs.join(' ').scan(/[^\s+]+/)
+    Dao.libdir{ libs.each{|lib| Kernel.load(lib) } }
+  end
+
+  extend Dao
+end

data/lib/dao/active_record.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 begin
-  ActiveRecord
-  ActiveRecord::Base
+  ActiveRecord.name
+  ActiveRecord::Base.name
 rescue NameError
   nil
 end
@@ -12,10 +12,10 @@ if defined?(ActiveRecord)
     class Base
       def Base.to_dao(*args)
         if args.first.is_a?(Base)
-          record_to_dao(record = args.shift, *args)
+          record_to_dao(args.shift, *args)
         else
           @to_dao ||= (
-            names = column_names ### + reflect_on_all_associations.map(&:name)
+            column_names ### + reflect_on_all_associations.map(&:name)
           )
           @to_dao = Array(args) unless args.empty?
           @to_dao
@@ -101,10 +101,10 @@ if defined?(ActiveRecord)
           end
 
           if attr.is_a?(Hash)
-            attr.each do |related, argv|
-              v = record.send(related)
-              value = v.respond_to?(:to_dao) ? v.to_dao(*argv) : v
-              map[related] = value
+            attr.each do |rel, _argv|
+              v = record.send(rel)
+              value = v.respond_to?(:to_dao) ? v.to_dao(*_argv) : v
+              map[rel] = value
             end
             next
           end

data/lib/dao/api/call.rb

@@ -13,13 +13,14 @@ module Dao
           :endpoints => Map.new,
           :blocks => {},
           :README => [],
-          :docs => []
+          :docs => [],
+          :paths => [],
         }
       end
 
       def call(*args, &block)
         options = Dao.options_for!(args)
-        path = Path.new(args.shift || raise(ArgumentError, "no path!"))
+        path = Path.new(args.shift || paths.shift || raise(ArgumentError, "no path!"))
 
         api = self
 
@@ -44,7 +45,12 @@ module Dao
 
         endpoints[path] = endpoint
       end
-      alias_method('endpoint', 'call')
+
+      def endpoint(path, &block)
+        paths << path.to_s
+        class_eval(&block)
+      end
+      #alias_method('endpoint', 'call')
 
       def endpoints
         state[:endpoints]
@@ -71,6 +77,10 @@ module Dao
         state[:docs]
       end
 
+      def paths
+        state[:paths]
+      end
+
       def readme(*args)
         if args.empty?
           state[:README]
@@ -232,7 +242,12 @@ module Dao
 
   # delgate some methods to the context
   #
-    Context.attrs.each do |method|
+    (Context.attrs - %w[ status data ]).each do |method|
+      if method_defined?(method)
+        #p [method, instance_method(method).source_location].join(':')
+        remove_method(method)
+      end
+
       module_eval <<-__, __FILE__, __LINE__
         def #{ method }(*args)
           context.send(#{ method.inspect }, *args)

data/lib/dao/api/dsl.rb

@@ -33,7 +33,7 @@ module Dao
 
     class << Api
       def evaluate(&block)
-        @dsl ||= DSL.new(api=self)
+        @dsl ||= DSL.new(self)
         @dsl.evaluate(&block)
       end
       alias_method('configure', 'evaluate')

data/lib/dao/coerce.rb

@@ -0,0 +1,211 @@
+module Dao
+  module Coerce
+  ## built-in
+  #
+    require 'uri'
+    require 'time'
+    require 'date'
+    require 'pathname'
+    require 'chronic'
+
+  ## version
+  #
+    Coerce::Version = '0.0.8'
+
+    def self.version
+      Coerce::Version
+    end
+
+  ## dependencies
+  #
+    def self.dependencies
+      {
+        'chronic'   =>  [ 'chronic'   , '>= 0.6.2' ]
+      }
+    end
+
+    begin
+      require 'rubygems'
+    rescue LoadError
+      nil
+    end
+
+    if defined?(gem)
+      self.dependencies.each do |lib, dependency|
+        gem(*dependency)
+        require(lib)
+      end
+    end
+
+  ##
+  #
+    def self.export m
+      module_function m
+      public m
+    end
+
+    List = []
+
+    def self.coerce m, &b
+      define_method m, &b
+      export m
+      List << m.to_s
+    end
+
+    coerce :boolean do |obj|
+      case obj.to_s
+        when %r/^(true|t|1|yes|y|on)$/i
+          true
+        when %r/^(false|f|0|no|n|off)$/i
+          false
+        else
+          !!obj
+      end
+    end
+
+    coerce :integer do |obj|
+      Float(obj).to_i
+    end
+
+    coerce :float do |obj|
+      Float obj
+    end
+
+    coerce :number do |obj|
+      Float obj rescue Integer obj
+    end
+
+    coerce :string do |obj|
+      String obj
+    end
+
+    coerce :symbol do |obj|
+      String(obj).to_sym
+    end
+
+    coerce :uri do |obj|
+      ::URI.parse obj.to_s
+    end
+
+    coerce :url do |obj|
+      ::URI.parse(obj.to_s).to_s
+    end
+
+    coerce :time do |obj|
+      ::Chronic.parse(obj.to_s)
+    end
+
+    coerce :date do |obj|
+      begin
+        ::Date.parse(::Chronic.parse(obj.to_s).to_s)
+      rescue
+        ::Date.parse(obj.to_s)
+      end
+    end
+
+    coerce :pathname do |obj|
+      Pathname.new(obj.to_s)
+    end
+
+    coerce :path do |obj|
+      File.expand_path(obj.to_s)
+    end
+
+    coerce :input do |obj|
+      case obj.to_s
+        when '-'
+          io = STDIN.dup
+          io.fattr(:path){ '/dev/stdin' }
+          io
+        else
+          io = open(obj.to_s, 'r+')
+          at_exit{ io.close }
+          io
+      end
+    end
+
+    coerce :output do |obj|
+      case obj.to_s
+        when '-'
+          io = STDOUT.dup
+          io.fattr(:path){ '/dev/stdout' }
+          io
+        else
+          io = open(obj.to_s, 'w+')
+          at_exit{ io.close }
+          io
+      end
+    end
+
+    coerce :slug do |obj|
+      string = [obj].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?}
+      String(words.join('-').downcase)
+    end
+
+    coerce :list do |*objs|
+      [*objs].flatten.join(',').split(/[\n,]/).map{|item| item.strip}.delete_if{|item| item.strip.empty?}
+    end
+
+    coerce :array do |*objs|
+      [*objs].flatten.join(',').split(/[\n,]/).map{|item| item.strip}.delete_if{|item| item.strip.empty?}
+    end
+
+    coerce :hash do |*objs|
+      list = Coerce.list(*objs)
+      hash = Hash.new
+      list.each do |pair|
+        k, v = pair.split(/[=:]+/, 2)
+        key = k.to_s.strip
+        val = v.to_s.strip
+        hash[key] = val
+      end
+      hash
+    end
+
+  # add list_of_xxx methods
+  #
+    List.dup.each do |type|
+      next if type.to_s =~ %r/list/ 
+      %W" list_of_#{ type } list_of_#{ type }s ".each do |m|
+        define_method m do |*objs|
+          list(*objs).map{|obj| send type, obj}
+        end
+        export m 
+        List << m
+      end
+    end
+
+  # add list_of_xxx_from_file
+  #
+    List.dup.each do |type|
+      next if type.to_s =~ %r/list/ 
+      %W" list_of_#{ type }_from_file list_of_#{ type }s_from_file ".each do |m|
+        define_method m do |*args|
+          buf = nil
+          if args.size == 1 and args.first.respond_to?(:read)
+            buf = args.first.read
+          else
+            open(*args){|io| buf = io.read}
+          end
+          send(m.sub(/_from_file/, ''), buf)
+        end
+        export m
+        List << m
+      end
+    end
+
+    def self.[] sym
+      prefix = sym.to_s.downcase.to_sym
+      candidates = List.select{|m| m =~ %r/^#{ prefix }/i}
+      m = candidates.shift
+      raise ArgumentError, "unsupported coercion: #{ sym.inspect } (#{ List.join ',' })" unless
+        m
+      raise ArgumentError, "ambiguous coercion: #{ sym.inspect } (#{ List.join ',' })" unless
+        candidates.empty? or m.to_s == sym.to_s
+      lambda{|obj| method(m).call obj}
+    end
+  end
+end

data/lib/dao/conducer.rb

@@ -86,14 +86,10 @@ module Dao
   # instance methods
   #
     %w[
-      attributes
-      form
       params
-      errors
       messages
       models
       model
-      conduces
     ].each{|attr| fattr(attr)}
 
   # ctors
@@ -117,7 +113,7 @@ module Dao
             controller.send(:action_name).to_s
         end
 
-      conducer = new(Action.new(action), *args, &block)
+      new(Action.new(action), *args, &block)
     end
 
     def Conducer.call(*args, &block)
@@ -243,7 +239,7 @@ module Dao
     end
 
     def conduces?(model)
-      if @model
+      if defined?(@model)
         @model == model
       else
         self.class.conduces?(model)
@@ -323,6 +319,10 @@ module Dao
       update_attributes(attributes)
     end
 
+    def attributes
+      @attributes
+    end
+
     def set(*args, &block)
       update_attributes(*args, &block)
     end
@@ -348,8 +348,8 @@ module Dao
     def method_missing(method, *args, &block)
       re = /^([^=!?]+)([=!?])?$/imox
 
-      matched, key, suffix = re.match(method.to_s).to_a
-      
+      _, key, suffix = re.match(method.to_s).to_a
+
       case suffix
         when '='
           set(key, args.first)
@@ -399,10 +399,10 @@ module Dao
     end
 
     def id_for(object)
-      model?(object) ? object.id : object
+      modelish?(object) ? object.id : object
     end
 
-    def model?(object)
+    def modelish?(object)
       object.respond_to?(:persisted?)
     end
 
@@ -478,10 +478,6 @@ module Dao
       Dao.key_for(key)
     end
 
-    def errors
-      validator.errors
-    end
-
     def model_name
       self.class.model_name
     end

data/lib/dao/conducer/controller_support.rb

@@ -28,6 +28,11 @@ module Dao
         @controller.send(:request) if @controller
       end
 
+      def request_method
+        method = request.try(:method)
+        method ? method.to_s.to_sym.upcase : nil
+      end
+
     ##
     #
       class Action < ::String

data/lib/dao/conducer/view_support.rb

@@ -10,9 +10,7 @@ module Dao
         def install_routes!
           url_helpers = Rails.application.try(:routes).try(:url_helpers)
           include(url_helpers) if url_helpers
-          include(ActionView::Helpers) if defined?(ActionView::Helpers)
           extend(url_helpers) if url_helpers
-          extend(ActionView::Helpers) if defined?(ActionView::Helpers)
         end
       end
     end