dao 3.3.0 → 4.2.1

data/lib/dao/exceptions.rb

@@ -1,6 +1,5 @@
 module Dao
-  class Dao::Error < ::StandardError
-  end
+  class Dao::Error < ::StandardError; end
 
   class Dao::Error::Result < Error
     attr_accessor :result

data/lib/dao/extractor.rb

@@ -0,0 +1,68 @@
+module Dao
+  class Extractor < BlankSlate
+    attr :target
+    attr :extracted
+    attr :strategies
+
+    def initialize(target, *args, &block)
+      @target = target
+      @strategies = Map.new
+      @extracted = Map.new
+      extracts(*args)
+    end
+
+    def inspect
+      @extracted.inspect
+    end
+
+    def extracts(*args, &block)
+      hashes = []
+
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          hashes.push(arg)
+        else
+          if block
+            hashes.push(arg => block)
+          end
+        end
+      end
+
+      hashes.each do |hash|
+        hash.each do |key, val|
+          next unless val.respond_to?(:call)
+          @strategies[key] = val
+        end
+      end
+
+      self
+    end
+
+    def method_missing(method, *args, &block)
+      super unless @strategies.has_key?(method)
+      extract(method, &@strategies[method])
+    end
+
+    def extract(attribute, &block)
+      return @extracted[attribute] if @extracted.has_key?(attribute)
+
+      if @target.respond_to?(attribute)
+        value = @target.send(attribute)
+        @extracted[attribute] = value
+        return @extracted[attribute]
+      end
+
+      ivar = "@#{ attribute }"
+      if @target.instance_variable_defined?(ivar)
+        value = @target.instance_variable_get(ivar)
+        @extracted[attribute] = value
+        return @extracted[attribute]
+      end
+
+      if block
+        @extracted[attribute] = block.call
+        return @extracted[attribute]
+      end
+    end
+  end
+end

data/lib/dao/form.rb

@@ -18,26 +18,110 @@ module Dao
 
   # instance methods
   #
-    attr_accessor :map
+    attr_accessor :object
 
-    def initialize(*args, &block)
-      @map = args.first.is_a?(Map) ? args.shift : Map.new
+    def initialize(*args)
+      @object = args.shift
     end
 
-    def errors
-      @map.errors
+    fattr(:attributes) do
+      attributes =
+        catch(:attributes) do
+          if @object.respond_to?(:attributes)
+            throw :attributes, @object.attributes
+          end
+          if @object.instance_variable_defined?('@attributes')
+            throw :attributes, @object.instance_variable_get('@attributes')
+          end
+          if @object.is_a?(Map)
+            throw :attributes, @object
+          end
+          if @object.respond_to?(:to_map)
+            throw :attributes, Map.new(@object.to_map)
+          end
+          if @object.is_a?(Hash)
+            throw :attributes, Map.new(@object)
+          end
+          if @object.respond_to?(:to_hash)
+            throw :attributes, Map.new(@object.to_hash)
+          end
+          Map.new
+        end
+
+      case attributes
+        when Map
+          attributes
+        when Hash
+          Map.new(attributes)
+        else
+          raise(ArgumentError.new("#{ attributes.inspect } (#{ attributes.class })"))
+      end
     end
 
-    def path
-      @map.path
+    fattr(:name) do
+      name =
+        catch(:name) do
+          if @object.respond_to?(:name)
+            throw :name, @object.name
+          end
+          if @object.instance_variable_defined?('@name')
+            throw :name, @object.instance_variable_get('@name')
+          end
+          'form'
+        end
+
+      case name
+        when Symbol, String
+          name.to_s
+        else
+          raise(ArgumentError.new("#{ name.inspect } (#{ name.class })"))
+      end
+    end
+
+    fattr(:errors) do
+      errors =
+        catch(:errors) do
+          if @object.respond_to?(:errors)
+            throw :errors, @object.errors
+          end
+          if @object.instance_variable_defined?('@errors')
+            throw :errors, @object.instance_variable_get('@errors')
+          end
+          Errors.new
+        end
+
+      case errors
+        when Errors
+          errors
+        else
+          raise(ArgumentError.new("#{ errors.inspect } (#{ errors.class })"))
+      end
     end
 
+    fattr(:status) do
+      status =
+        catch(:status) do
+          if @object.respond_to?(:status)
+            throw :status, @object.status
+          end
+          if @object.instance_variable_defined?('@status')
+            throw :status, @object.instance_variable_get('@status')
+          end
+          Status.new
+        end
 
+      case status
+        when Status
+          status
+        else
+          raise(ArgumentError.new("#{ status.inspect } (#{ status.class })"))
+      end
+    end
 
   # html generation methods 
   #
     def form(*args, &block)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = args.extract_options!.to_options! 
       keys = args.flatten
 
       action = options.delete(:action) || './'
@@ -57,7 +141,7 @@ module Dao
     end
 
     def label(*args, &block)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = args.extract_options!.to_options! 
       keys = args.flatten
 
       id = options.delete(:id) || id_for(keys)
@@ -67,7 +151,7 @@ module Dao
 
       content =
         if block.nil? and !options.has_key?(:content)
-          humanize(keys.last)
+          titleize(keys.last)
         else
           block ? block.call() : options.delete(:content)
         end
@@ -76,7 +160,7 @@ module Dao
     end
 
     def input(*args, &block)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = args.extract_options!.to_options! 
       keys = args.flatten
 
       type = options.delete(:type) || :text
@@ -87,16 +171,16 @@ module Dao
 
       value =
         if block.nil? and !options.has_key?(:value) 
-          value_for(@map, keys)
+          value_for(attributes, keys)
         else
-          block ? block.call(@map.get(keys)) : options.delete(:value)
+          block ? block.call(attributes.get(keys)) : options.delete(:value)
         end
 
       input_(options_for(options, :type => type, :name => name, :value => value, :class => klass, :id => id, :data_error => error)){}
     end
 
     def submit(*args, &block)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = args.extract_options!.to_options! 
 
       content = block ? block.call : (args.first || 'Submit')
 
@@ -108,7 +192,7 @@ module Dao
     end
 
     def button(*args)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = args.extract_options!.to_options! 
       keys = args.flatten
 
       type = options.delete(:type) || :button
@@ -119,23 +203,23 @@ module Dao
 
       value =
         if block.nil? and !options.has_key?(:value) 
-          value_for(@map, keys)
+          value_for(attributes, keys)
         else
-          block ? block.call(@map.get(keys)) : options.delete(:value)
+          block ? block.call(attributes.get(keys)) : options.delete(:value)
         end
 
       button_(options_for(options, :type => type, :name => name, :value => value, :class => klass, :id => id, :data_error => error)){}
     end
 
     def reset(*args)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = args.extract_options!.to_options! 
       options[:type] = :reset
       args.push(options)
       button(*args)
     end
 
     def textarea(*args, &block)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = args.extract_options!.to_options! 
       keys = args.flatten
 
       name = options.delete(:name) || name_for(keys)
@@ -145,27 +229,27 @@ module Dao
 
       value =
         if block.nil? and !options.has_key?(:value) 
-          value_for(@map, keys)
+          value_for(attributes, keys)
         else
-          block ? block.call(@map.get(keys)) : options.delete(:value)
+          block ? block.call(attributes.get(keys)) : options.delete(:value)
         end
 
       textarea_(options_for(options, :name => name, :class => klass, :id => id, :data_error => error)){ value.to_s }
     end
 
     def select(*args, &block)
-      options = Dao.map_for(args.last.is_a?(Hash) ? args.pop : {})
+      options = args.extract_options!.to_options! 
       keys = args.flatten
 
       name = options.delete(:name) || name_for(keys)
-      from = options.delete(:from) || options.delete(:options)
+      from = options.delete(:from) || options.delete(:options) || attributes.get(*keys)
       blank = options.delete(:blank)
 
       selected =
         if options.has_key?(:selected)
           options.delete(:selected)
         else
-          value_for(@map, keys)
+          value_for(attributes, keys)
         end
 
       id = options.delete(:id) || id_for(keys)
@@ -177,7 +261,7 @@ module Dao
       if from.nil?
         key = keys.map{|key| "#{ key }"}
         key.last << "_options"
-        from = @map.get(*key) if @map.has?(*key)
+        from = attributes.get(*key) if attributes.has?(*key)
       end
 
       list = Array(from)
@@ -242,13 +326,21 @@ module Dao
   # html generation support methods
   #
     def id_for(keys)
-      id = [path, keys.join('-')].compact.join('_')
+      id = [name, keys.join('-')].compact.join('_')
       slug_for(id)
     end
 
+    def errors_on(keys)
+      errors.get(keys)
+    end
+
+    def errors_on?(*keys)
+      !errors_on(keys).blank?
+    end
+
     def class_for(keys, klass = nil)
       klass = 
-        if errors.on?(keys)
+        if errors_on?(keys)
           [klass, 'dao', 'errors'].compact.join(' ')
         else
           [klass, 'dao'].compact.join(' ')
@@ -257,31 +349,32 @@ module Dao
     end
 
     def error_for(keys, klass = nil)
-      errors.get(keys) if errors.on?(keys)
+      if errors_on?(keys)
+        title = Array(keys).join(' ').titleize
+        messages = Array(errors.get(keys)).join(', ')
+        "#{ title }: #{ messages }"
+      end
     end
 
     def value_for(map, keys)
       return nil unless map.has?(keys)
-      value = Tagz.escapeHTML(map.get(keys))
-    end
-
-    def Form.name_for(path, *keys)
-      path = Path.new(path) unless path.is_a?(Path)
-      "#{ path }(#{ Array(keys).flatten.compact.join(',') })"
-    end
-
-    def Form.name_re_for(path)
-      path = Path.new(path) unless path.is_a?(Path)
-      Regexp.new(/^#{ Regexp.escape(path) }/)
+      value = map.get(keys)
+      value =
+        case value
+          when Hash, Array
+            value.to_json
+          else
+            value
+        end
+      Tagz.escapeHTML(value)
     end
 
-    def Form.encoded?(path, params)
-      name_re = Form.name_re_for(path)
-      params.keys.any?{|key| name_re =~ key.to_s}
+    def Form.name_for(name, *keys)
+      "dao[#{ name }][#{ Array(keys).flatten.compact.join('.') }]"
     end
 
-    def name_for(keys)
-      Form.name_for(path, keys)
+    def name_for(*keys)
+      Form.name_for(name, *keys)
     end
 
     def options_for(*hashes)
@@ -304,9 +397,9 @@ module Dao
       slug_for(string).gsub(/_/, '-')
     end
 
-    def humanize(string)
+    def titleize(string)
       string = string.to_s
-      string = string.humanize if string.respond_to?(:humanize)
+      string = string.titleize if string.respond_to?(:titleize)
       string
     end
   end

data/lib/dao/image_cache.rb

@@ -0,0 +1,193 @@
+module Dao
+  require 'uuidtools'
+  require 'fileutils'
+  require 'cgi'
+
+  class ImageCache
+    Version = '1.0.0'
+
+    class << ImageCache
+      def version
+        ImageCache::Version
+      end
+
+      def base
+        @base ||= 'images/cache'
+      end
+
+      def base=(base)
+        @base = base.to_s.sub(%r|^/+|, '')
+      end
+
+      def url
+        '/' + base
+      end
+
+      def root
+        @root ||= File.join(Rails.root, 'public', base)
+      end
+
+      def uuid(*args)
+        UUIDTools::UUID.timestamp_create.to_s
+      end
+
+      def tmpdir(&block)
+        tmpdir = File.join(root, uuid)
+
+        if block
+          FileUtils.mkdir_p(tmpdir)
+          block.call(tmpdir)
+        else
+          tmpdir
+        end
+      end
+
+      def cleanname(path)
+        basename = File.basename(path.to_s)
+        CGI.unescape(basename).gsub(%r/[^0-9a-zA-Z_@)(~.-]/, '_').gsub(%r/_+/,'_')
+      end
+
+      def cache_key_for(key)
+        "#{ key }__cache"
+      end
+
+      def for(params, key = :image)
+        image = params[key]
+        if image.respond_to?(:read)
+          tmpdir do |tmp|
+            basename = cleanname(image.original_path)
+
+            path = File.join(tmp, basename)
+            open(path, 'w'){|fd| fd.write(image.read)}
+            image_cache = new(key, path)
+            params[key] = image_cache.io
+            return image_cache
+          end
+        end
+
+        cache_key = cache_key_for(key)
+        image_cache = params[cache_key]
+        if image_cache
+          dirname, basename = File.split(image_cache)
+          path = root + '/' + File.join(File.basename(dirname), basename)
+          image_cache = new(key, path)
+          params[key] = image_cache.io
+          return image_cache
+        end
+
+        return new(key, path=nil)
+      end
+
+      def finalizer(object_id)
+        if fd = IOs[object_id]
+          IO.for_fd(fd).close
+          IOs.delete(object_id)
+        end
+      end
+
+      UUIDPattern = %r/^[a-zA-Z0-9-]+$/io
+      Age = 60 * 60 * 24
+
+      def clear!(options = {})
+        glob = File.join(root, '*')
+        age = Integer(options[:age] || options['age'] || Age)
+        since = options[:since] || options['since'] || Time.now
+
+        Dir.glob(glob) do |entry|
+          begin
+            next unless test(?d, entry)
+            next unless File.basename(entry) =~ UUIDPattern
+
+            files = Dir.glob(File.join(entry, '**/**'))
+
+            all_files_are_old =
+              files.all? do |file|
+                begin
+                  stat = File.stat(file)
+                  age = since - stat.atime
+                  age >= Age
+                rescue
+                  false
+                end
+              end
+
+            FileUtils.rm_rf(entry) if all_files_are_old
+          rescue
+            next
+          end
+        end
+      end
+    end
+
+    attr_accessor :key
+    attr_accessor :cache_key
+    attr_accessor :path
+    attr_accessor :dirname
+    attr_accessor :basename
+    attr_accessor :value
+    attr_accessor :io
+
+    IOs = {}
+
+    def initialize(key, path)
+      @key = key.to_s
+      @cache_key = ImageCache.cache_key_for(key)
+
+      if path
+        @path = path
+        @dirname, @basename = File.split(@path)
+        @value = File.join(File.basename(@dirname), @basename).strip
+        @io = open(@path)
+        IOs[object_id] = @io.fileno
+        ObjectSpace.define_finalizer(self, ImageCache.method(:finalizer).to_proc)
+      else
+        @path = nil
+        @value = nil
+      end
+    end
+
+    def hidden
+      raw("<input type='hidden' name='#{ @cache_key }' value='#{ @value }' />") if @value
+    end
+
+    def to_s
+      hidden.to_s
+    end
+
+    def url
+      File.join(ImageCache.url, @value) if @value
+    end
+
+    def raw(*args)
+      string = args.join
+      if string.respond_to?(:html_safe)
+        string.html_safe
+      else
+        string
+      end
+    end
+
+    def clear!
+      FileUtils.rm_rf(@dirname) if test(?d, @dirname)
+    rescue
+      nil
+    ensure
+      if @io
+        @io.close
+        IOs.delete(object_id)
+      end
+      Thread.new{ ImageCache.clear! }
+    end
+  end
+
+  Image_cache = ImageCache unless defined?(Image_cache)
+
+  if defined?(Rails.env)
+    unless Rails.env.production?
+      if defined?(unloadable)
+        unloadable(ImageCache)
+        unloadable(Image_cache)
+      end
+    end
+  end
+end