spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/extensions/nil.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Spontaneous::Extensions
+  module NilClass
+    def /(alternative)
+      alternative
+    end
+  end # String
+end # Extensions
+
+class NilClass
+  include Spontaneous::Extensions::NilClass
+end

data/lib/spontaneous/facet.rb

@@ -2,18 +2,36 @@
 
 module Spontaneous
   class Facet
+
     def initialize(root)
-      @root = root
+      @root = File.expand_path(root)
       paths.add :lib, ["lib", "**/*.rb"]
       paths.add :schema, ["schema", "**/*.rb"]
       paths.add :templates, "templates"
       paths.add :config, "config"
+      paths.add :public, "public"
       paths.add :tasks, ["lib/tasks", "**/*.rake"]
       paths.add :migrations, ["db/migrations", "**/*.rake"]
       paths.add :plugins, ["plugins", "*"]
       paths.add :features, "features"
     end
 
+
+    def root(*path)
+      return @root if path.empty?
+      File.join(@root, path)
+    end
+
+    def name
+      File.basename(root)
+    end
+
+    # used by publishing mechanism to place files into the appropriate subdirectories
+    # in the public folder.
+    def file_namespace
+      name
+    end
+
     def paths
       @paths ||= Spontaneous::Paths.new(@root)
     end
@@ -28,19 +46,55 @@ module Spontaneous
       end
     end
 
+    def load_indexes!
+      paths.expanded(:config).each do |config_path|
+        index_file = config_path / "indexes.rb"
+        Kernel.load(index_file) if File.exists?(index_file)
+      end
+    end
+
     def init!
     end
 
     def load!
-      Spontaneous::Loader.load_classes(load_paths)
+      load_order.each { |category| load_files(category) }
+    end
+
+    def load_files(category)
+      loaders[category].load!
+    end
+
+
+    def reload_all!
+      load_order.each { |category| loaders[category].reload! }
+    end
+    alias_method :reload!, :reload_all!
+
+    def load_order
+      [:lib, :schema]
+    end
+
+    def loaders
+      @loaders ||= \
+        begin
+          use_reloader = config.reload_classes
+          {
+            :schema => Spontaneous::SchemaLoader.new(schema_load_paths, use_reloader),
+            :lib => Spontaneous::Loader.new(load_paths, use_reloader)
+          }
+        end
     end
 
     def load_paths
-      load_paths = []
-      [:lib, :schema].each do |category|
-        load_paths += paths.expanded(category)
-      end
-      load_paths
+      load_paths_for_category(:lib)
+    end
+
+    def schema_load_paths
+      load_paths_for_category(:schema)
+    end
+
+    def load_paths_for_category(category)
+      self.paths.expanded(category)
     end
 
   end # Facet

data/lib/spontaneous/field_types.rb

@@ -1,7 +1,5 @@
 # encoding: UTF-8
 
-
-
 module Spontaneous
   module FieldTypes
 
@@ -35,6 +33,6 @@ module Spontaneous
   end
 end
 
-[:string, :image, :date, :markdown].each do |type|
+[:string, :long_string, :image, :date, :markdown, :location, :webvideo].each do |type|
   require "spontaneous/field_types/#{type}_field"
 end

data/lib/spontaneous/field_types/date_field.rb

@@ -4,6 +4,7 @@
 module Spontaneous
   module FieldTypes
     class DateField < Field
+      include Spontaneous::Plugins::Field::EditorClass
     end
 
     DateField.register

data/lib/spontaneous/field_types/field.rb

@@ -4,9 +4,11 @@
 module Spontaneous
   module FieldTypes
     class Field
+      extend Plugins
 
       def self.register(*labels)
         labels = self.labels if labels.empty?
+        # logger.debug("Registering #{self} as #{labels.join(", ")}")
         FieldTypes.register(self, *labels)
         self
       end
@@ -15,6 +17,14 @@ module Spontaneous
         [self.name.demodulize.gsub(/Field$/, '').underscore]
       end
 
+      def self.inherited(subclass, real_caller = nil)
+        if self.respond_to?(:editor_class)
+          editor_class = self.editor_class
+          subclass.singleton_class.send(:define_method, :editor_class) do
+            editor_class
+          end
+        end
+      end
       # def self.prototype=(prototype)
       #   @prototype = prototype
       # end
@@ -33,9 +43,12 @@ module Spontaneous
         end
       end
 
+
       attr_accessor :owner, :name, :unprocessed_value, :template_params, :version
       attr_reader   :processed_values
 
+      alias_method :values, :processed_values
+
 
       def initialize(params={}, from_db=false)
         @processed_values = {}
@@ -108,7 +121,7 @@ module Spontaneous
       # override this to return custom values derived from (un)processed_value
       # alias_method :value, :processed_value
       def value(format=:html)
-        processed_values[format] || unprocessed_value
+        processed_values[format.to_sym] || unprocessed_value
       end
       alias_method :processed_value, :value
 
@@ -116,6 +129,10 @@ module Spontaneous
         false
       end
 
+      def indexable_value
+        unprocessed_value
+      end
+
       def to_s(format = :html)
         value(format).to_s
       end
@@ -186,28 +203,36 @@ module Spontaneous
       #   "spontaneous:previewedit:end:field id:#{owner.id} name:#{self.name}"
       # end
 
-      def export
+      def export(user)
         {
         :name => name.to_s,
         :id => schema_id.to_s,
         :unprocessed_value => unprocessed_value,
-        :processed_value => value(:html),
-        :values => processed_values,
+        :processed_value => ui_preview_value,
         :version => version
         }
       end
 
+      def ui_preview_value
+        value(:html)
+      end
+
       def inspect
         %(#<#{self.class.name}:#{self.object_id} #{self.serialize_db.inspect}>)
       end
 
       def blank?
-        value.blank?
+        unprocessed_value.blank?
       end
 
-      def empty?
-        value.empty?
+      alias_method :empty?, :blank?
+
+
+      def /(field)
+        return field if self.blank?
+        self
       end
+      alias_method :'|', :/
 
       protected
 
@@ -233,14 +258,6 @@ module Spontaneous
         @preprocessed = nil
       end
 
-      def method_missing(method_name, *args)
-        if self.has_attribute?(method_name)
-          attribute_get(method_name, *args)
-        else
-          super
-        end
-      end
-
       def set_unprocessed_value(new_value)
         # initial_value should only be set once so that it can act as a test for field modification
         @initial_value ||= new_value

data/lib/spontaneous/field_types/image_field.rb

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 
+require 'tempfile'
 require 'mini_magick'
 require 'delegate'
 
@@ -49,9 +50,15 @@ module Spontaneous
       def to_s
         src
       end
+
+      def /(value)
+        return value if self.blank?
+        self
+      end
     end
 
     class ImageField < Field
+      include Spontaneous::Plugins::Field::EditorClass
       include ImageFieldUtilities
 
       def self.accepts
@@ -66,7 +73,7 @@ module Spontaneous
             def #{name}
               sizes[:#{name}]
             end
-            IMAGE
+          IMAGE
         end
       end
 
@@ -79,7 +86,7 @@ module Spontaneous
       end
 
       def self.size_definitions
-        @size_definitions ||= {}
+        @size_definitions ||= superclass.respond_to?(:size_definitions) ? superclass.size_definitions.dup : {}
       end
 
       def image?
@@ -129,33 +136,49 @@ module Spontaneous
         sizes[:original].src
       end
 
-      def generate(output, image_path)
-        return { :src => image_path } unless File.exist?(image_path)
-        image = ImageProcessor.new(image_path)
-        result = \
+      def generate(output, media_file)
+        return { :src => media_file } if media_file.is_a?(String)#File.exist?(image_path)
+        image = ImageProcessor.new(media_file)
+        # Create a tempfile here that will be kept open for the duration of the block
+        # this is used in #apply to hold a copy of the processed image data rather than
+        # rely on the minimagick generated tempfiles which can get closed
+        result = Tempfile.open("image_#{output}") do |tempfile|
           case output
           when :original
             image
           else
             process = self.class.size_definitions[output]
-            image.apply(process, output)
+            image.apply(process, output, tempfile)
           end
+        end
         result.serialize
       end
 
       def preprocess(image_path)
-        filename = nil
+        filename = mimetype = nil
         case image_path
         when Hash
+          mimetype = image_path[:type]
           filename = image_path[:filename]
           image_path = image_path[:tempfile].path
         when String
           # return image_path unless File.exist?(image_path)
+          filename = ::File.basename(image_path)
         end
         return image_path unless File.exist?(image_path)
-        media_path = owner.make_media_file(image_path, filename)
-        set_unprocessed_value(File.expand_path(media_path))
-        media_path
+        # media_path = owner.make_media_file(image_path, filename)
+        media_file = Spontaneous::Media::File.new(owner, filename, mimetype)
+        media_file.copy(image_path)
+        set_unprocessed_value(File.expand_path(media_file.filepath))
+        # media_path
+        # image_path
+        media_file
+      end
+
+      def export(user = nil)
+        super(user).merge({
+          :processed_value => processed_values
+        })
       end
     end
 
@@ -183,78 +206,118 @@ module Spontaneous
       def inspect
         %(<#{self.class.name}: src=#{src.inspect} width="#{width}" height="#{height}">)
       end
+
+      def blank?
+        src.blank?
+      end
+
+      alias_method :empty?, :blank?
     end
 
     class ImageProcessor
       include ImageFieldUtilities
 
-      class ImageDelegator < Delegator
-        attr_reader :image
+      class ImageDelegator < SimpleDelegator
 
         def initialize(image)
-          super
-          @image = image
+          super(image)
         end
 
-        def __getobj__
-          @image
-        end
+        alias_method :image, :__getobj__
 
-        def __setobj__(obj)
-          @image = obj
+        def format(*args, &block)
+          image.format(*args, &block)
         end
 
-        def __run__(process)
-          combine_options do |c|
-            cb = CommandDelegator.new(c)
-            cb.__run__(process)
+        def fit(width, height)
+          image.combine_options do |c|
+            c.add_command(:geometry, "#{width}x#{height}>")
           end
         end
-      end
 
-      class CommandDelegator < Delegator
-        def initialize(command_builder)
-          super
-          @command_builder = command_builder
+        def crop(width, height)
+          image.combine_options do |c|
+            dimensions = "#{width}x#{height}"
+            c.add_command(:geometry, "#{dimensions}^")
+            c.add_command(:gravity, "center")
+            c.add_command(:crop, "#{dimensions}+0+0!")
+          end
         end
 
-        def __getobj__
-          @command_builder
+        def width(width)
+          image.combine_options do |c|
+            c.add_command(:geometry, "#{width}x>")
+          end
         end
 
-        def __setobj__(obj)
-          @command_builder = obj
+        def height(height)
+          image.combine_options do |c|
+            c.add_command(:geometry, "x#{height}>")
+          end
         end
 
-        def __run__(process)
-          instance_eval(&process)
+        def greyscale
+          image.combine_options do |c|
+            c.add_command(:type, "Grayscale")
+          end
         end
 
-        def fit(width, height)
-          add(:geometry, "#{width}x#{height}>")
+        def composite(other_image_path, output_extension = "jpg", &block)
+          File.open(other_image_path) do |other_image|
+            new_image = image.composite(other_image, output_extension, &block)
+            image.path = new_image.path
+          end
         end
 
-        def crop(width, height)
-          dimensions = "#{width}x#{height}"
-          add(:geometry, "#{dimensions}^")
-          add(:gravity, "center")
-          add(:crop, "#{dimensions}+0+0!")
-        end
+        def border_radius(radius, bg_color = nil)
+          @image.format('png') if bg_color.nil? or bg_color == 'transparent'
+          puts @image.path
+          c = MiniMagick::CommandBuilder.new('convert')
+          c << @image.path
+          c.add_command(:format, "roundrectangle 0,0 %[fx:w-1],%[fx:h-1], 10,10")
+          c.add_command(:write, "info:tmp.mvg")
+          c << @image.path
+
+          puts c.command
+          # @image.run(c)
+          sub = Subexec.run(c.command, :timeout => MiniMagick.timeout)
+
+          c = MiniMagick::CommandBuilder.new('convert')
+
+          c << @image.path
+          # c.add_command(:write, "info:tmp.mvg")
+          c.add_command(:matte)
+          c.add_command(:bordercolor, "none")
+          c.add_command(:border, "0")
+          c.push('\\(')
+          c.push("+clone")
+          c.add_command(:alpha, 'transparent')
+          c.add_command(:background, 'white')
+          c.add_command(:fill, 'white')
+          c.add_command(:stroke, 'none')
+          c.add_command(:strokewidth, '0')
+          c.add_command(:draw, "@tmp.mvg")
+          c.push('\\)')
+          c.add_command(:compose, 'DstIn')
+          c.add_command(:composite)
+          c << @image.path
+          puts c.command
+          @image.run(c)
 
-        def width(width)
-          add(:geometry, "#{width}x>")
         end
 
-        def height(height)
-          add(:geometry, "x#{height}>")
-        end
 
-        def greyscale
-          add(:type, "Grayscale")
+        def __run__(process)
+          instance_eval(&process)
         end
 
         def method_missing(method, *args, &block)
-          __getobj__.send(method, *args, &block)
+          params = args.map(&:to_s)
+          if image.respond_to?(method)
+            image.__send__(method, *params, &block)
+          else
+            image.method_missing(method, *params, &block)
+          end
         end
       end
 
@@ -262,17 +325,13 @@ module Spontaneous
 
       attr_reader :path
 
-      def initialize(path)
-        @path = File.expand_path(path)
+      def initialize(media_file)
+        @media_file = media_file
+        @path = media_file.source
       end
 
       def src
-        @src ||= \
-          begin
-            media_dir = Spontaneous.media_dir
-            src = path.sub(%r{^#{media_dir}}, '')
-            File.join("/#{File.basename(media_dir)}", src)
-          end
+        @media_file.url
       end
 
       def filesize
@@ -291,24 +350,31 @@ module Spontaneous
         @dimensions ||= Spontaneous::ImageSize.read(path)
       end
 
-      def apply(process, name)
+      def apply(process, name, tempfile)
         image = ::MiniMagick::Image.open(path)
         processor = ImageProcessor::ImageDelegator.new(image)
         processor.__run__(process)
-        file_path = filename_for_size(name)
-        image.write(file_path)
+        file = @media_file.rename(filename_for_size(name, image))
+        # copy the image into the tempfile provided by the parent #generate call
+        # this stops us from using a tempfile that is out of our control and can
+        # be closed before we're done
+        FileUtils.cp(image.path, tempfile.path)
+        file.copy(tempfile)
 
-        ImageProcessor.new(file_path)
+        ImageProcessor.new(file)
       end
 
-      def filename_for_size(name)
-        directory = File.dirname(path)
-        original_filename = File.basename(path)
+      def filename_for_size(name, image)
+        original_filename = @media_file.filename
         parts = original_filename.split('.')
-        ext = parts[-1]
+
+        # use the image format for the extension because tempfiles generated by
+        # mini_magick don't have extensions
+        # I hate the "jpeg" extension though
+        ext = image[:format].downcase.gsub(/^jpeg$/, "jpg")
         base = parts[0..-2].join('.')
         filename = [base, name, ext].join('.')
-        File.join(directory, filename)
+        filename
       end
 
       def serialize
@@ -320,10 +386,13 @@ module Spontaneous
           :path => path
         }
       end
+
+      def inspect
+        %(#<ImageProcessor:#{self.object_id} @media_file=#{@media_file.inspect}>)
+      end
     end
 
     ImageField.register(:image, :photo)
 
   end
 end
-