spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/lib/spontaneous/generators/site.rb

@@ -6,9 +6,9 @@ module Spontaneous
   module Generators
     class Site < Thor::Group
       def self.available_dbs
-        { "mysql"      => { :gem => "mysql2", :adapter => "mysql2" },
-          "postgresql" => { :gem => "pg", :adapter => "postgres" },
-          "postgres"   => { :gem => "pg", :adapter => "postgres" } }
+        postgres = { :gem => "pg", :adapter => "postgres", :user => nil }
+        { "mysql"      => { :gem => "mysql2", :adapter => "mysql2", :user => "root" },
+          "pg" => postgres,  "postgresql" =>  postgres, "postgres"   =>  postgres }
       end
 
       def self.source_root; File.expand_path(File.dirname(__FILE__) + "/site"); end
@@ -18,53 +18,58 @@ module Spontaneous
 
       argument :domain, :type => :string, :desc => "The domain name of the site to generate"
 
-      class_option :root,    :desc => "The root destination", :aliases => '-r', :default => ".",   :type => :string
-      class_option :database,    :desc => "The database to use ('mysql' (default) or 'postgres')", :aliases => %w(-d --db), :default => "mysql",   :type => :string
-      class_option :user,    :desc => "The database account to use", :aliases => '-u', :default => "root",   :type => :string
-      class_option :password,    :desc => "The password for the database user", :aliases => %w(-p), :default => "",   :type => :string
-      class_option :host,    :desc => "The database host", :aliases => %w(-h), :default => "",   :type => :string
+      class_option :root,     :desc => "The root destination", :aliases => '-r', :default => ".",   :type => :string
+      class_option :database, :desc => "The database to use ('postgres' (default) or 'mysql')", :aliases => %w(-d --db), :default => "postgres",   :type => :string
+      class_option :user,     :desc => "The database account to use", :aliases => '-u', :type => :string
+      class_option :password, :desc => "The password for the database user", :aliases => %w(-p), :default => "",   :type => :string
+      class_option :host,     :desc => "The database host", :aliases => %w(-h),   :type => :string
 
 
       desc "Generates a new site for DOMAIN"
       def create_site
         if self.class.available_dbs.keys.include?(options.database)
-          spec = Gem::Specification.load(File.expand_path("../../../../spontaneous.gemspec", __FILE__))
-          adapter = self.class.available_dbs[options.database]
-          adapter_dependency =  spec.development_dependencies.detect { |dependency| dependency.name == adapter[:gem] }
-          @valid = true
           say "Generating '#{domain}'...", :bold
-          @domain = domain
+          @domain    = domain
           @site_name = domain.to_s.gsub(/\./, "_")
           @username  = domain.split(/\./).first
-          @database  = { :user => options.user, :adapter => adapter[:adapter], :gem => adapter_dependency, :password => options.password, :host => options.host }
+          @database  = {
+            :user => options.user || adapter[:user],
+            :adapter => adapter[:adapter],
+            :gem => adapter_dependency,
+            :password => options.password,
+            :host => options.host
+          }
           self.destination_root = options[:root]
           empty_directory(@site_name)
           self.destination_root = self.destination_root / @site_name
-          directory "config"
-          directory "schema"
-          directory "lib"
-          directory "templates"
-          directory "public"
-          template "Gemfile.tt", "Gemfile"
-          template "Capfile.tt", "Capfile"
-          template "Rakefile.tt", "Rakefile"
-          # template "lib/site.rb.tt", "lib/site.rb"
-          # empty_directory "lib/tasks"
-          empty_directory "log"
-          empty_directory "tmp"
-          empty_directory "cache/media"
-          empty_directory "cache/tmp"
-          empty_directory "cache/revisions"
-          copy_file ".gitignore"
           # template "lib/tasks/site.rake.tt", "lib/tasks/#{@site_name}.rake"
         else
-          @valid = false
           say "Invalid database selection '#{options.database}'. Valid options are: #{self.class.available_dbs.keys.join(', ')}", :red
+          exit 1
         end
       end
 
-      def finish_message
-        return unless @valid
+      def generate
+        directory "config"
+        directory "schema"
+        directory "lib"
+        directory "templates"
+        directory "assets"
+        directory "public"
+        template "Gemfile.tt", "Gemfile"
+        template "Capfile.tt", "Capfile"
+        template "Rakefile.tt", "Rakefile"
+        # template "lib/site.rb.tt", "lib/site.rb"
+        # empty_directory "lib/tasks"
+        empty_directory "log"
+        empty_directory "tmp"
+        empty_directory "cache/media"
+        empty_directory "cache/tmp"
+        empty_directory "cache/revisions"
+        copy_file ".gitignore"
+      end
+
+      def finish_message_1
         message = (<<-MSG).gsub(/^ +/, '')
 
 
@@ -72,21 +77,58 @@ module Spontaneous
 
         Site #{@domain} is ready.
 
+        MSG
+        say(message, :bold)
+      end
+
+      def finish_message_2
+        message = (<<-MSG).gsub(/^ +/, '')
         To start using your new CMS do the following:
         ---------------------------------------------------------
+        MSG
+        say(message)
+      end
+
+      def finish_message_3
+        message = (<<-MSG).gsub(/^ +/, '')
         1. cd #{options[:root]}/#{@site_name}
         2. bundle install
         3. spot init
+        MSG
+        say(message.chomp, :green)
+      end
+
+      def finish_message_4
+        message = (<<-MSG).gsub(/^ +/, '')
+        ---------------------------------------------------------
 
         Then go to
 
-          http://spontaneous.io/documentation
+          http://spontaneous.io/
 
-        and read the many useful guides to getting started with Spontaneous.
+        and read the many useful guides to getting started with
+        Spontaneous.
 
         MSG
         say(message)
       end
+
+      private
+
+      def adapter
+        self.class.available_dbs[options.database]
+      end
+
+      # Source adapter versions from Spontaneous's gemfile. This way
+      # sites are generated using the same version that tests are run against
+      def adapter_dependency
+        gemfile = (File.expand_path("../../../../Gemfile", __FILE__))
+        saved_gemfile, ENV['BUNDLE_GEMFILE'] = ENV['BUNDLE_GEMFILE'], gemfile
+        spec = Bundler::Dsl.new
+        spec.eval_gemfile(gemfile)
+        ENV['BUNDLE_GEMFILE'] = saved_gemfile
+        spec.dependencies.detect { |dependency| dependency.name == adapter[:gem] }
+      end
     end # Site
   end # Generators
 end # Spontaneous

data/lib/spontaneous/layout.rb

@@ -17,16 +17,15 @@ module Spontaneous
     end
 
     class Anonymous
-      def initialize(template_proc)
-        @template_proc = template_proc
+      def initialize(templates = {})
+        @templates = templates
       end
 
       def template(format = :html)
-        @template_proc
-      end
-
-      def exists?(format = :html)
-        true
+        template = @templates[format]
+        # a layout without a format is used as a fallback
+        template ||= @templates[nil]
+        template
       end
 
       def name

data/lib/spontaneous/loader.rb

@@ -1,10 +1,8 @@
 # encoding: UTF-8
 
-require 'active_support/ordered_hash'
+require 'pathname'
 
 module Spontaneous
-  OrderedHash = ActiveSupport::OrderedHash unless defined?(OrderedHash)
-
   class Loader
     attr_reader :use_reloader, :load_paths
 
@@ -110,7 +108,7 @@ module Spontaneous
         @cache          = {}
         @mtimes         = {}
         @files_loaded   = {}
-        @loaded_classes = {}
+        @loaded_classes = Hash.new { |h, k| h[k] = [] }
       end
 
       def reset!
@@ -167,7 +165,7 @@ module Spontaneous
       def safe_load(file, mtime=nil)
         reload = mtime && mtime > mtimes[file]
 
-        logger.debug "Reloading #{file}" if reload
+        logger.debug "Reloading #{relativize_path(file)}" if reload
 
         # Removes all classes declared in the specified file
         if klasses = loaded_classes.delete(file)
@@ -189,6 +187,7 @@ module Spontaneous
 
         # Duplicate objects and loaded features in the file
         klasses = ObjectSpace.classes.dup
+        modules = ObjectSpace.modules.dup
         already_loaded = $LOADED_FEATURES.dup
 
         # Start to re-require old dependencies
@@ -224,24 +223,35 @@ module Spontaneous
         # And finally reload the specified file
         begin
           require(file)
-        # rescue => ex
-        #   logger.fatal "Cannot require #{file}\\\\\\\\n#{ex.message}"
-        #   raise ex
+        rescue => e
+          # logger.info "Failed to load '#{relativize_path(file)}' : #{e.message}"
+          raise e
         ensure
+          # Ensure that any classes loaded by the file before it failed get
+          # added to the list of loaded classes for a file.
+          # Without this a long file with an error will only record classes
+          # loaded after the error has been resolved.
+          new_objects = (ObjectSpace.classes - klasses) + (ObjectSpace.modules - modules)
+          loaded_classes[file].concat(new_objects)
           mtimes[file] = mtime if mtime
         end
 
         # Store the file details after successful loading
-        loaded_classes[file] = ObjectSpace.classes - klasses
         self.files_loaded[file]   = $LOADED_FEATURES - already_loaded
 
-        nil
+        loaded_classes[file]
+      end
+
+      def relativize_path(path)
+        pwd = Pathname.new(Dir.pwd)
+        Pathname.new(path).relative_path_from(pwd)
       end
 
       ##
       # Removes the specified class and constant.
       #
       def remove_constant(const)
+        const.__finalize if const.respond_to?(:__finalize)
         Spontaneous.schema.delete(const)
 
         parts = const.to_s.split("::")
@@ -379,9 +389,7 @@ module Spontaneous
       end
 
       def remove_constant(const)
-        if is_schema_class?(const)
-          super
-        end
+        super if is_schema_class?(const)
       end
 
       def dependency_file?(file)

data/lib/spontaneous/media/file.rb

@@ -8,36 +8,51 @@ module Spontaneous::Media
 
     attr_reader :filename, :owner, :source
 
-    def initialize(owner, filename, mimetype = nil)
-      @owner, @filename, @mimetype = owner, Spontaneous::Media.to_filename(filename), mimetype
+    def initialize(owner, filename, headers = {})
+      headers = { content_type: headers } if headers.is_a?(String)
+      @owner, @filename, @headers = owner, Spontaneous::Media.to_filename(filename), headers
     end
 
+    # Create a new File instance with a new name.
+    # This new file instance should take its content type from the new name
+    # because one of the uses of this is during image size creation where we
+    # might be converting from one format to another.
     def rename(new_filename)
-      self.class.new(owner, new_filename, nil)
+      headers = storage_headers
+      headers.delete(:content_type)
+      self.class.new(owner, new_filename, headers)
     end
 
     def open(mode = 'wb', &block)
-      storage.open(storage_path, mimetype, mode, &block)
+      storage.open(storage_path, storage_headers, mode, &block)
     end
 
     def copy(existing_file)
       @source = existing_file.respond_to?(:path) ? existing_file.path : existing_file
-      storage.copy(existing_file, storage_path, mimetype)
+      storage.copy(existing_file, storage_path, storage_headers)
       self
     end
 
+    def storage_headers
+      headers = @headers.dup
+      headers[:content_type] ||= mimetype
+      headers
+    end
+
     def url
       storage.public_url(storage_path)
     end
 
     def mimetype
-      @mimetype ||= ::Rack::Mime.mime_type(ext)
+      @mimetype ||= ( @headers[:content_type] || ::Rack::Mime.mime_type(ext) )
     end
 
     def ext
       F.extname(filename)
     end
 
+    alias_method :extname, :ext
+
     def filesize
       F.size(source)
     end
@@ -78,10 +93,8 @@ module Spontaneous::Media
       F.join(storage.root, media_dir)
     end
 
-    alias_method :filepath, :path
-
     def serialize
-      { :url => url, :mimetype => mimetype, :path => path, :filename => filename }
+      { :url => url, :type => mimetype, :filename => filename }
     end
   end
 end

data/lib/spontaneous/media/image/attributes.rb

@@ -0,0 +1,33 @@
+module Spontaneous::Media
+  module Image
+    class Attributes
+      include Renderable
+
+      attr_reader  :src, :width, :height, :filesize, :filepath
+
+      def initialize(params={})
+        params ||= {}
+        @src, @width, @height, @filesize, @filepath = params.values_at(:src, :width, :height, :filesize, :path)
+      end
+
+      def serialize
+        { :src => src, :width => width, :height => height, :filesize => filesize }
+      end
+
+      def inspect
+        %(<#{self.class.name}: src=#{src.inspect} width="#{width}" height="#{height}">)
+      end
+
+      def blank?
+        src.blank?
+      end
+
+      # Will only work for files in local storage
+      def filepath
+        Spontaneous::Media.to_filepath(src)
+      end
+
+      alias_method :empty?, :blank?
+    end
+  end
+end

data/lib/spontaneous/media/image/format/gif.rb

@@ -0,0 +1,4 @@
+Spontaneous::Media::Image.define :gif, [71, 73, 70, 56] do |file|
+  file.seek(6)
+  file.read(4).unpack('vv')
+end

data/lib/spontaneous/media/image/format/jpg.rb

@@ -0,0 +1,17 @@
+Spontaneous::Media::Image.define :jpg, [255, 216] do |file|
+  markers = [192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207]
+  height = width = 0
+  c_marker = 255 # Section marker.
+  file.seek(2)
+  while(true)
+    marker, code, length = file.read(4).unpack('CCn')
+    raise "Invalid JPG file: marker not found! '#{file.path}'" if marker != c_marker
+
+    if markers.include?(code)
+      height, width = file.read(5).unpack('xnn')
+      break
+    end
+    file.seek(length - 2, IO::SEEK_CUR)
+  end
+  [width, height]
+end

data/lib/spontaneous/media/image/format/png.rb

@@ -0,0 +1,4 @@
+Spontaneous::Media::Image.define :png, [137, 80, 78, 71, 13, 10, 26, 10] do |file|
+  file.seek(16)
+  file.read(8).unpack('NN')
+end

data/lib/spontaneous/media/image/format/webp.rb

@@ -0,0 +1,26 @@
+Spontaneous::Media::Image.define :webp, [82, 73, 70, 70, nil, nil, nil, nil, 87, 69, 66, 80] do |file|
+  file.seek(12)
+  format = file.read(4)
+  height = width = 0
+  uint24 = proc { |bytes| (bytes + 0.chr).unpack("V").first }
+  uint14 = proc { |int|  int & 0x3fff }
+
+  case format
+  when "VP8 " #simple-file-format-lossy
+    file.seek(10, IO::SEEK_CUR)
+    # two 14 bit ints with 2 bits of scaling info
+    header = file.read(4).unpack("v*")
+    width, height = header.map(&uint14)
+  when "VP8L" #simple-file-format-lossless
+    file.seek(5, IO::SEEK_CUR)
+    # two consecutive 14 bit ints
+    header = file.read(4).unpack("v*")
+    width  = uint14[header[0]] + 1
+    height = (header[0] >> 14) + ((header[1] & 0xfff) << 2) + 1
+  when "VP8X" #extended-file-format
+    file.seek(8, IO::SEEK_CUR)
+    width  = uint24[file.read(3)] + 1
+    height = uint24[file.read(3)] + 1
+  end
+  [width, height]
+end

data/lib/spontaneous/media/image/format.rb

@@ -0,0 +1,79 @@
+module Spontaneous::Media::Image
+  class Format
+    def initialize(image, attributes = nil)
+      @image, @attributes = image, attributes
+    end
+
+    def format
+      attributes[:format]
+    end
+
+    def dimensions
+      attributes[:dimensions]
+    end
+
+    def size
+      attributes[:filesize]
+    end
+
+    def src
+      [:src, :path].each do |m|
+        return @image.send(m) if @image.respond_to?(m)
+      end
+      @image
+    end
+
+    def attributes
+      @attributes ||= read_attributes
+    end
+
+    def serialize
+      attributes.merge(:format => format.to_s)
+    end
+
+    def inspect
+      %(#<Spontaneous::Media::Image::#{format.to_s.upcase} #{size}B #{dimensions.join("x")} #{src}>)
+    end
+
+    private
+
+    def read_attributes
+      open do |file|
+        analyze(file)
+      end
+    end
+
+    def analyze(file)
+      size = file.size
+      return to_attributes(nil) if size == 0
+      header = Spontaneous::Media::Image.peek(file)
+      file.rewind
+      Spontaneous::Media::Image.formats.each do |format, (magic, dim)|
+        bytes = header[0, magic.length].zip(magic)
+        if bytes.all? { |b, m| m.nil? || b == m }
+          return to_attributes(format, size, dim.call(file))
+        end
+      end
+      to_attributes(:unknown, size)
+    end
+
+    def to_attributes(format, size = 0, dimensions = [0,0])
+      { :format => format, :filesize => size, :dimensions => dimensions,
+        :width => dimensions[0], :height => dimensions[1] }
+    end
+
+    def open(&block)
+      if @image.respond_to?(:read) # IO
+        yield @image
+      elsif @image.respond_to?(:open) # Media::File
+        @image.open do |file|
+          block.call(file)
+        end
+      else # Probably string
+        File.open(@image, 'rb') do |file|
+          block.call(file)
+        end
+      end
+    end
+  end
+end

data/lib/spontaneous/media/image/optimizer.rb

@@ -0,0 +1,69 @@
+require 'shellwords'
+
+module Spontaneous::Media::Image
+  class Optimizer
+    def self.run(source_image)
+      self.new(source_image).run
+    end
+
+    def self.binary(cmd)
+      (@binaries ||={})[cmd] ||= find_binary(cmd)
+    end
+
+    def self.find_binary(name)
+      binary = `which #{name}`.chomp
+      return nil if binary.length == 0
+      binary
+    end
+
+    def initialize(source_image)
+      @image = source_image
+    end
+
+    def run
+      format = Spontaneous::Media::Image.format(@image)
+      if respond_to?(format)
+        send(format)
+      end
+    end
+
+    def jpg
+      run_optimization("jpegoptim", "-o -q --strip-all --preserve --force #{@image} 2>&1 1>/dev/null")
+      # run_optimization("jpegtran", "-optimize -progressive -copy none -outfile #{input} #{input}")
+    end
+
+    def png
+      # pngcrush refuses to play if the input & output are the same
+      Tempfile.open("crushme", :binmode => true) do |temp|
+        ::File.open(@image, "rb") { |src| IO.copy_stream(src, temp) }
+        run_optimization("pngcrush", "-rem alla -reduce -cc #{temp.path} #{@image}")
+      end
+    end
+
+    def run_optimization(lib, args)
+      exe = binary(lib)
+      return unless exe
+      command = [exe, args].join(" ")
+      logger.debug(command)
+      measure do
+        process = POSIX::Spawn::Child.new(command)
+        unless process.success?
+          logger.error("Error optimizing image: #{@image}\n#{process.err}")
+        end
+        process.status
+      end
+    end
+
+    def measure
+      before, start = ::File.size(@image), Time.now
+      result = yield
+      after, _end  = ::File.size(@image), Time.now
+      logger.debug("#{(100 * (1 - after.to_f/before.to_f)).round(1)}% optimization of '#{::File.basename(@image)}' [#{before} -> #{after}] in #{_end - start}s")
+      result
+    end
+
+    def binary(cmd)
+      self.class.binary(cmd)
+    end
+  end
+end

data/lib/spontaneous/media/image/processor.rb

@@ -0,0 +1,17 @@
+module Spontaneous::Media::Image
+  class Processor
+    include Spontaneous::Media::Image::Skeptick
+
+    def initialize(input, output)
+      @input, @output = input, output
+    end
+
+    def apply(process)
+      cmd = convert(@input, :to => @output, &process)
+      cmd.run
+    end
+
+    def optimize!
+    end
+  end
+end

data/lib/spontaneous/media/image/renderable.rb

@@ -0,0 +1,52 @@
+
+module Spontaneous::Media::Image
+  module Renderable
+    attr_accessor :template_params
+
+    def render(format=:html, *args)
+      case format
+      when "html", :html
+        to_html(*args)
+      else
+        value
+      end
+    end
+
+    def to_html(attr={})
+      default_attr = {
+        :src => src,
+        :width => width,
+        :height => height,
+        :alt => ""
+      }
+      default_attr.delete(:width) if width.nil?
+      default_attr.delete(:height) if height.nil?
+      if template_params && template_params.length > 0 && template_params[0].is_a?(Hash)
+        attr = template_params[0].merge(attr)
+      end
+      if attr.key?(:width) || attr.key?(:height)
+        default_attr.delete(:width)
+        default_attr.delete(:height)
+        if (attr.key?(:width) && !attr[:width]) || (attr.key?(:height) && !attr[:height])
+          attr.delete(:width)
+          attr.delete(:height)
+        end
+      end
+      attr = default_attr.merge(attr)
+      params = []
+      attr.each do |name, value|
+        params << %(#{name}="#{value.to_s.escape_html}")
+      end
+      %(<img #{params.join(' ')} />)
+    end
+
+    def to_s
+      src
+    end
+
+    def /(value)
+      return value if self.blank?
+      self
+    end
+  end
+end