dragonfly 0.9.15 → 1.0

data/lib/dragonfly/configurable.rb

@@ -2,205 +2,106 @@ module Dragonfly
   module Configurable
 
     # Exceptions
-    class NotConfigured < RuntimeError; end
-    class BadConfigAttribute < RuntimeError; end
-
-    def self.included(klass)
-      klass.class_eval do
-        include Configurable::InstanceMethods
-        extend Configurable::ClassMethods
-      end
-    end
-
-    class DeferredBlock # Inheriting from Proc causes errors in some versions of Ruby
-      def initialize(blk)
-        @blk = blk
-      end
-
-      def call
-        @blk.call
-      end
-    end
-
-    module InstanceMethods
-
-      def configure(&block)
-        yield ConfigurationProxy.new(self)
-        self
-      end
-
-      def configure_with(config, *args, &block)
-        config = saved_config_for(config) if config.is_a?(Symbol)
-        config.apply_configuration(self, *args)
-        configure(&block) if block
-        self
-      end
-
-      def has_config_method?(method_name)
-        config_methods.include?(method_name.to_sym)
-      end
-      
-      def configuration
-        @configuration ||= {}
-      end
-            
-      def config_methods
-        @config_methods ||= self.class.config_methods.dup
-      end
-      
-      def default_configuration
-        @default_configuration ||= self.class.default_configuration.dup
-      end
-
-      def set_config_value(key, value)
-        configuration[key] = value
-        child_configurables.each{|c| c.set_if_unset(key, value) }
-        value
-      end
-      
-      def use_as_fallback_config(other_configurable)
-        other_configurable.add_child_configurable(self)
-        self.fallback_configurable = other_configurable
-      end
-
-      protected
-
-      def add_child_configurable(obj)
-        child_configurables << obj
-        config_methods.push(*obj.config_methods)
-        fallback_configurable.config_methods.push(*obj.config_methods) if fallback_configurable
-      end
-
-      def set_if_unset(key, value)
-        set_config_value(key, value) unless set_locally?(key)
-      end
-
-      private
-      
-      attr_accessor :fallback_configurable
-      
-      def child_configurables
-        @child_configurables ||= []
-      end
-      
-      def set_locally?(key)
-        instance_variable_defined?("@#{key}")
-      end
-      
-      def default_value(key)
-        if default_configuration[key].is_a?(DeferredBlock)
-          default_configuration[key] = default_configuration[key].call
+    class UnregisteredPlugin < RuntimeError; end
+
+    class Configurer
+
+      class << self
+        private
+
+        def writer(*args)
+          names, opts = extract_options(args)
+          names.each do |name|
+            define_method name do |value|
+              if opts[:for]
+                obj.send(opts[:for]).send("#{name}=", value)
+              else
+                obj.send("#{name}=", value)
+              end
+            end
+          end
         end
-        default_configuration[key]
-      end
-
-      def saved_configs
-        self.class.saved_configs
-      end
 
-      def saved_config_for(symbol)
-        config = saved_configs[symbol]
-        if config.nil?
-          raise ArgumentError, "#{symbol.inspect} is not a known configuration - try one of #{saved_configs.keys.join(', ')}"
+        def meth(*args)
+          names, opts = extract_options(args)
+          names.each do |name|
+            define_method name do |*args, &block|
+              if opts[:for]
+                obj.send(opts[:for]).send(name, *args, &block)
+              else
+                obj.send(name, *args, &block)
+              end
+            end
+          end
         end
-        config = config.call if config.respond_to?(:call)
-        config
-      end
-
-    end
 
-    module ClassMethods
-
-      def default_configuration
-        @default_configuration ||= configurable_ancestors.reverse.inject({}) do |default_config, klass|
-          default_config.merge!(klass.default_configuration)
-          default_config
+        def extract_options(args)
+          opts = args.last.is_a?(Hash) ? args.pop : {}
+          [args, opts]
         end
       end
 
-      def config_methods
-        @config_methods ||= configurable_ancestors.inject([]) do |conf_methods, klass|
-          conf_methods |= klass.config_methods
-          conf_methods
-        end
+      def initialize(&block)
+        (class << self; self; end).class_eval(&block)
       end
 
-      def nested_configurables
-        @nested_configurables ||= []
+      def configure(obj, &block)
+        previous_obj = @obj
+        @obj = obj
+        instance_eval(&block)
+        @obj = previous_obj
       end
 
-      def register_configuration(name, config=nil, &config_in_block) 
-        saved_configs[name] = config_in_block || config
+      def configure_with_plugin(obj, plugin, *args, &block)
+        if plugin.is_a?(Symbol)
+          symbol = plugin
+          raise(UnregisteredPlugin, "plugin #{symbol.inspect} is not registered") unless registered_plugins[symbol]
+          plugin = registered_plugins[symbol].call
+          obj.plugins[symbol] = plugin if obj.respond_to?(:plugins)
+        end
+        plugin.call(obj, *args, &block)
+        plugin
       end
 
-      def saved_configs
-        @saved_configs ||= {}
+      def register_plugin(name, &block)
+        registered_plugins[name] = block
       end
 
-      def configurable_ancestors
-        @configurable_ancestors ||= ancestors.select{|a| a.included_modules.include?(Configurable) } - [self]
+      def plugin(plugin, *args, &block)
+        configure_with_plugin(obj, plugin, *args, &block)
       end
 
       private
 
-      def configurable_attr attribute, default=nil, &blk
-        default_configuration[attribute] = blk ? DeferredBlock.new(blk) : default
-
-        # Define the reader
-        define_method(attribute) do
-          configuration.has_key?(attribute) ? configuration[attribute] : default_value(attribute)
-        end
-
-        # Define the writer
-        define_method("#{attribute}=") do |value|
-          instance_variable_set("@#{attribute}", value)
-          set_config_value(attribute, value)
-        end
+      attr_reader :obj
 
-        configuration_method attribute
-        configuration_method "#{attribute}="
+      def registered_plugins
+        @registered_plugins ||= {}
       end
-
-      def configuration_method(*method_names)
-        config_methods.push(*method_names.map{|n| n.to_sym }).uniq!
-      end
-      
-      def nested_configurable(*method_names)
-        nested_configurables.push(*method_names)
-      end
-
     end
 
-    class ConfigurationProxy
+    #######
 
-      def initialize(owner)
-        @owner = owner
-      end
-
-      def method_missing(method_name, *args, &block)
-        if owner.has_config_method?(method_name)
-          attribute = method_name.to_s.tr('=','').to_sym
-          if method_name.to_s =~ /=$/ && owner.has_config_method?(attribute) # a bit hacky - if it has both getter and setter, assume it's a configurable_attr
-            owner.set_config_value(attribute, args.first)
-          else
-            owner.send(method_name, *args, &block)
-          end
-        elsif nested_configurable?(method_name)
-          owner.send(method_name)
-        else
-          raise BadConfigAttribute, "You tried to configure using '#{method_name.inspect}',  but the valid config attributes are #{owner.config_methods.map{|a| %('#{a.inspect}') }.sort.join(', ')}"
+    def set_up_config(&setup_block)
+      self.configurer = Configurer.new(&setup_block)
+      class_eval do
+        def configure(&block)
+          self.class.configurer.configure(self, &block)
+          self
         end
-      end
-
-      private
 
-      attr_reader :owner
+        def configure_with(plugin, *args, &block)
+          self.class.configurer.configure_with_plugin(self, plugin, *args, &block)
+          self
+        end
 
-      def nested_configurable?(method)
-        owner.class.nested_configurables.include?(method.to_sym)
+        def plugins
+          @plugins ||= {}
+        end
       end
-
     end
 
+    attr_accessor :configurer
+
   end
 end

data/lib/dragonfly/content.rb

@@ -0,0 +1,211 @@
+require 'base64'
+require 'forwardable'
+require 'dragonfly/has_filename'
+require 'dragonfly/temp_object'
+require 'dragonfly/utils'
+
+module Dragonfly
+
+  # A Dragonfly::Content object is responsible for holding
+  # 1. content (in the form of a data string, file, tempfile, or path)
+  # 2. metadata about the content (i.e. name, etc.)
+  # Furthermore, it belongs to a Dragonfly app, so has access to its already registered generators, processors, analysers and datastore.
+  # It provides convenience methods for updating its content, and though the original data may have been in the form of a String, or a Pathname, etc.
+  # methods like "path", "data" and "file" will always work regardless.
+  #
+  # It is acted upon in generator, processor, analyser and datastore methods and provides a standard interface for updating content,
+  # no matter how that content first got there (whether in the form of a String/Pathname/File/etc.)
+  class Content
+
+    include HasFilename
+    extend Forwardable
+
+    def initialize(app, obj="", meta=nil)
+      @app = app
+      @meta = {}
+      @previous_temp_objects = []
+      update(obj, meta)
+    end
+
+    attr_reader :app
+    def_delegators :app,
+                   :analyser, :generator, :processor, :shell, :datastore, :env
+
+    attr_reader :temp_object
+
+    # @return [Hash]
+    attr_accessor :meta
+
+    # @!method data
+    #   @return [String] the content data as a string (even if it was initialized with a file)
+    # @!method file
+    #   @example
+    #     content.file
+    #   @example With a block (it closes the file at the end)
+    #     content.file do |f|
+    #       # do something with f
+    #     end
+    #   @return [File] the content as a readable file (even if it was initialized with data)
+    # @!method path
+    #   @return [String] a file path for the content (even if it was initialized with data)
+    # @!method size
+    #   @return [Fixnum] the size in bytes
+    # @!method to_file
+    #   @param [String] path
+    #   @return [File] a new file
+    # @!method to_tempfile
+    #   @return [Tempfile] a new tempfile
+    def_delegators :temp_object,
+                   :data, :file, :tempfile, :path, :size, :each, :to_file, :to_tempfile
+
+    # @example "beach.jpg"
+    # @return [String]
+    def name
+      meta["name"] || temp_object.original_filename
+    end
+
+    # @example
+    #   content.name = "beach.jpg"
+    def name=(name)
+      meta["name"] = name
+    end
+
+    # The mime-type taken from the name's file extension
+    # @example "image/jpeg"
+    # @return [String]
+    def mime_type
+      app.mime_type_for(ext)
+    end
+
+    # Set the content using a pre-registered generator
+    # @example
+    #   content.generate!(:text, "some text")
+    # @return [Content] self
+    def generate!(name, *args)
+      app.get_generator(name).call(self, *args)
+      self
+    end
+
+    # Update the content using a pre-registered processor
+    # @example
+    #   content.process!(:convert, "-resize 300x300")
+    # @return [Content] self
+    def process!(name, *args)
+      app.get_processor(name).call(self, *args)
+      self
+    end
+
+    # Analyse the content using a pre-registered analyser
+    # @example
+    #   content.analyse(:width)  # ===> 280
+    def analyse(name)
+      analyser_cache[name.to_s] ||= app.get_analyser(name).call(self)
+    end
+
+    # Update the content
+    # @param obj [String, Pathname, Tempfile, File, Content, TempObject] can be any of these types
+    # @param meta [Hash] - should be json-like, i.e. contain no types other than String, Number, Boolean
+    # @return [Content] self
+    def update(obj, meta=nil)
+      self.temp_object = TempObject.new(obj)
+      original_filename = temp_object.original_filename
+      self.meta['name'] ||= original_filename if original_filename
+      self.meta.delete("analyser_cache")
+      add_meta(obj.meta) if obj.respond_to?(:meta)
+      add_meta(meta) if meta
+      self
+    end
+
+    # Add to the meta (merge)
+    # @param meta [Hash] - should be json-like, i.e. contain no types other than String, Number, Boolean
+    def add_meta(meta)
+      self.meta.merge!(meta)
+      self
+    end
+
+    # Analyse the content using a shell command
+    # @param opts [Hash] passing :escape => false doesn't shell-escape each word
+    # @example
+    #   content.shell_eval do |path|
+    #     "file --mime-type #{path}"
+    #   end
+    #   # ===> "beach.jpg: image/jpeg"
+    def shell_eval(opts={})
+      should_escape = opts[:escape] != false
+      command = yield(should_escape ? shell.quote(path) : path)
+      run command, :escape => should_escape
+    end
+
+    # Set the content using a shell command
+    # @param opts [Hash] :ext sets the file extension of the new path and :escape => false doesn't shell-escape each word
+    # @example
+    #   content.shell_generate do |path|
+    #     "/usr/local/bin/generate_text gumfry -o #{path}"
+    #   end
+    # @return [Content] self
+    def shell_generate(opts={})
+      ext = opts[:ext] || self.ext
+      should_escape = opts[:escape] != false
+      tempfile = Utils.new_tempfile(ext)
+      new_path = should_escape ? shell.quote(tempfile.path) : tempfile.path
+      command = yield(new_path)
+      run(command, :escape => should_escape)
+      update(tempfile)
+    end
+
+    # Update the content using a shell command
+    # @param opts [Hash] :ext sets the file extension of the new path and :escape => false doesn't shell-escape each word
+    # @example
+    #   content.shell_update do |old_path, new_path|
+    #     "convert -resize 20x10 #{old_path} #{new_path}"
+    #   end
+    # @return [Content] self
+    def shell_update(opts={})
+      ext = opts[:ext] || self.ext
+      should_escape = opts[:escape] != false
+      tempfile = Utils.new_tempfile(ext)
+      old_path = should_escape ? shell.quote(path) : path
+      new_path = should_escape ? shell.quote(tempfile.path) : tempfile.path
+      command = yield(old_path, new_path)
+      run(command, :escape => should_escape)
+      update(tempfile)
+    end
+
+    def store(opts={})
+      datastore.write(self, opts)
+    end
+
+    # @example
+    #   "data:image/jpeg;base64,IGSsdhfsoi..."
+    # @return [String] A data url representation of the data
+    def b64_data
+      "data:#{mime_type};base64,#{Base64.encode64(data)}"
+    end
+
+    def close
+      previous_temp_objects.each{|temp_object| temp_object.close }
+      temp_object.close
+    end
+
+    def inspect
+      "<#{self.class.name} temp_object=#{temp_object.inspect}>"
+    end
+
+    private
+
+    attr_reader :previous_temp_objects
+    def temp_object=(temp_object)
+      previous_temp_objects.push(@temp_object) if @temp_object
+      @temp_object = temp_object
+    end
+
+    def analyser_cache
+      meta["analyser_cache"] ||= {}
+    end
+
+    def run(command, opts)
+      shell.run(command, opts)
+    end
+
+  end
+end