spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/generators/site.rb

@@ -27,6 +27,7 @@ module Spontaneous
           say "Generating '#{domain}'...", :bold
           @domain = domain
           @site_name = domain.to_s.gsub(/\./, "_")
+          @username  = domain.split(/\./).first
           self.destination_root = options[:root]
           empty_directory(@site_name)
           self.destination_root = self.destination_root / @site_name

data/lib/spontaneous/json.rb

@@ -1,25 +1,48 @@
 # encoding: UTF-8
 
+require 'oj'
+
+Oj.default_options = {
+  symbol_keys: true,
+  mode: :compat
+} if defined?(Oj)
+
 module Spontaneous
   module JSON
-    module ModuleMethods
-      def parser
-        Yajl::Parser.new(:symbolize_keys => true)
-      end
-      def encoder
-        Yajl::Encoder.new
-      end
-
+    module OjParser
       def parse(json_string)
-        parser.parse(json_string)
+        ::Oj.load(json_string)
+      rescue
+        nil
       end
 
       def encode(object)
-        encoder.encode(object)
+        ::Oj.dump(object)
+      end
+    end
+
+    if defined?(Yajl)
+      module YajlParser
+        def parser
+          Yajl::Parser.new(:symbolize_keys => true)
+        end
+        def encoder
+          Yajl::Encoder.new
+        end
+
+        def parse(json_string)
+          parser.parse(json_string)
+        rescue
+          nil
+        end
+
+        def encode(object)
+          encoder.encode(object)
+        end
       end
     end
 
-    extend ModuleMethods
+    extend OjParser
 
     def parse_json(json_string)
       Spontaneous::JSON.parse(json_string)

data/lib/spontaneous/layout.rb

@@ -11,5 +11,27 @@ module Spontaneous
         [["layouts", "standard"]]
       end
     end
+
+    class Anonymous
+      def initialize(template_proc)
+        @template_proc = template_proc
+      end
+
+      def template(format = :html)
+        @template_proc
+      end
+
+      def exists?(format = :html)
+        true
+      end
+
+      def name
+        nil
+      end
+
+      def schema_id
+        nil
+      end
+    end
   end
 end

data/lib/spontaneous/media/file.rb

@@ -37,6 +37,10 @@ module Spontaneous::Media
       F.extname(filename)
     end
 
+    def filesize
+      F.size(source)
+    end
+
     def storage
       @storage ||= Spontaneous::Site.storage(mimetype)
     end

data/lib/spontaneous/output/assets/compression.rb

@@ -0,0 +1,58 @@
+require 'shine'
+require 'sass'
+
+module Spontaneous
+  module Output
+    module Assets
+      module Compression
+        extend self
+
+        def compress_js(filelist, options={})
+          shine_compress_files(filelist, :js, options)
+        end
+
+        def compress_js_string(js, options={})
+          shine_compress_string(js, :js, options)
+        end
+
+        def compress_css(filelist, options={})
+          # compress_files(filelist, :css, options)
+          opts = {
+            :load_paths => [Spontaneous.css_dir],
+            # :filename => sass_template,
+            :cache => false,
+            :style => :compressed
+          }.merge(options)
+          css = filelist.map do |path|
+            Sass::Engine.for_file(path, opts).render
+          end.join("\n")
+          hash = digest(css)
+          [css, hash]
+        end
+
+        def shine_compress_string(string, format, options = {})
+          compressed = Shine::compress_string(string, format, options).force_encoding("UTF-8")
+          hash = digest(compressed)
+          [compressed, hash]
+        end
+
+        def shine_compress_files(filelist, format, options = {})
+          original_size = filesize(filelist)
+          compressed = Shine::compress_files(filelist, format, options).force_encoding("UTF-8")
+          logger.info("Compressed #{filelist.length} files. Original size #{original_size}, compressed size #{compressed.length}, ratio #{(100*compressed.length.to_f/original_size.to_f).round}%")
+          hash = digest(compressed)
+          [compressed, hash]
+        end
+
+        def digest(str)
+          hash = Digest::SHA1.new.update(str).hexdigest
+        end
+
+
+        def filesize(paths)
+          paths.compact.inject(0) { |sum, path| sum += File.size(path) }
+        end
+      end
+    end
+  end
+end

data/lib/spontaneous/output/assets.rb

@@ -0,0 +1,32 @@
+module Spontaneous
+  module Output
+    module Assets
+      extend self
+
+      def compress_js(file_paths, options={})
+        Compression.compress_js(file_paths, options)
+      end
+
+      def url(file = nil)
+        Spontaneous::Output.asset_url(file)
+      end
+
+      def path_for(revision, path = nil)
+        File.join [Spontaneous::Output.asset_path(revision), path].compact
+      end
+
+      def find_file(*relative_paths)
+        relative_paths.flatten!
+        Spontaneous.instance.paths.expanded(:public).each do |root|
+          relative_paths.each do |relative_path|
+            path = root / relative_path
+            return path if ::File.exist?(path)
+          end
+        end
+        nil
+      end
+
+      autoload :Compression, "spontaneous/output/assets/compression"
+    end
+  end
+end

data/lib/spontaneous/output/context.rb

@@ -0,0 +1,179 @@
+
+module Spontaneous::Output::Context
+  module ContextCore
+    attr_accessor :__renderer
+
+    def navigation(depth = 1, &block)
+      case depth
+      when 0, :root
+        root
+      when 1, :section
+        navigation_at_depth(1, &block)
+      else
+        navigation_at_depth(depth, &block)
+      end
+    end
+
+    def navigation_at_depth(depth = 1)
+      current_page = __target.page
+      __pages_at_depth(current_page, depth).each do |p|
+        yield(p, current_page.active?(p))
+      end
+    end
+
+    def __pages_at_depth(origin_page, depth)
+      origin_page.at_depth(depth)
+    end
+
+    def page
+      __target.page
+    end
+
+    def live?
+      Spontaneous.production? && publishing?
+    end
+
+    def show_errors?
+      Spontaneous.development?
+    end
+
+    def root
+      Spontaneous::Site.root
+    end
+
+    def publishing?
+      false
+    end
+
+    def each
+      content.each { |c| yield(c) } if block_given?
+    end
+
+    def each_with_index
+      content.each_with_index { |c, i| yield(c, i) } if block_given?
+    end
+
+    def map
+      content.map { |c| yield(c) } if block_given?
+    end
+
+    def content
+      __target.iterable
+    end
+
+    def pieces
+      content
+    end
+
+    def render_content
+      __target.map do |c|
+        __render_content(c)
+      end.join("\n")
+    end
+
+    def first
+      content.first
+    end
+
+    def last
+      content.last
+    end
+
+    def first?
+      __target.owner.pieces.first == self
+    end
+
+    def last?
+      __target.owner.pieces.last == self
+    end
+
+    def __format
+      __loader.format
+    end
+
+    def __decode_params(param)
+      unless param.is_a?(String)
+        @_render_method ||= "to_#{__loader.format}".to_sym
+        if param.respond_to?(@_render_method)
+          param = param.send(@_render_method)
+        else
+          if param.respond_to?(:render)
+            param = __render_content(param) #render(param, param.template)
+          end
+        end
+      end
+      param.to_s
+    end
+
+    # Has to be routed through the top-level renderer so as to make
+    # use of shared caches that are held by it.
+    def __render_content(content)
+      if content.respond_to?(:render_using)
+        content.render_using(__renderer, __format, self)
+      else
+        content.render(__format, self)
+      end
+    end
+  end
+
+  module RenderCache
+    def _render_cache_value(key)
+      __renderer.render_cache[key]
+    end
+
+    def _render_cache_set_value(key, value)
+      __renderer.render_cache[key] = value
+    end
+
+    def _render_cache_key?(key)
+      __renderer.render_cache.key?(key)
+    end
+
+    def _with_render_cache(key, &value_block)
+      if _render_cache_key?(key)
+        _render_cache_value(key)
+      else
+        _render_cache_set_value(key, yield)
+      end
+    end
+  end
+
+  module PublishContext
+    include RenderCache
+
+    def root
+      _with_render_cache("site.root") do
+        super
+      end
+    end
+
+    def compressed_scripts(scripts)
+      _with_render_cache(scripts.join(",")) do
+        super(scripts)
+      end
+    end
+
+    def compressed_stylesheets(stylesheets)
+      _with_render_cache(stylesheets.join(",")) do
+        super(stylesheets)
+      end
+    end
+
+    def __pages_at_depth(origin_page, depth)
+      _with_render_cache("pages_at_depth.#{origin_page.id}.#{depth}") do
+        super
+      end
+    end
+
+    def publishing?
+      true
+    end
+  end
+
+  module PreviewContext
+  end
+
+  module RequestContext
+  end
+
+end

data/lib/spontaneous/output/format/html.rb

@@ -0,0 +1,5 @@
+module Spontaneous::Output
+  class HTML < Spontaneous::Output::Format
+    provides_format :html
+  end
+end

data/lib/spontaneous/output/format/plain.rb

@@ -0,0 +1,5 @@
+module Spontaneous::Output
+  class Plain < Spontaneous::Output::Format
+    provides_format :plain
+  end
+end

data/lib/spontaneous/output/format.rb

@@ -0,0 +1,180 @@
+
+module Spontaneous::Output
+  class Format
+    module ClassMethods
+      # class_attribute :template_engine
+
+      def inherited(subclass)
+        subclass.helper_formats.concat helper_formats
+      end
+
+      def provides_format(*formats)
+        helper_formats.concat formats
+        Spontaneous::Output.register_format(self, *formats)
+      end
+
+      def helper_formats
+        @helper_formats ||= []
+      end
+
+      def configure(output_name, options)
+        format    = options[:format]
+        extension = options[:extension]
+        language  = options[:language]
+        mimetype  = options[:mimetype] || options[:mime_type] || calculate_mimetype(format)
+        options.update({
+          :format => format.to_sym,
+          :mimetype => mimetype,
+          :extension => extension,
+          :language => language
+        })
+        @name    = output_name.to_sym
+        @options = default_options.merge(options)
+      end
+
+      def calculate_mimetype(format)
+        ::Rack::Mime.mime_type(".#{format}", nil) || inherited_mimetype
+      end
+
+      def default_options
+        { :private => false,
+          :dynamic => false }
+      end
+
+      def inherited_mimetype
+        ::Rack::Mime.mime_type(".#{helper_formats.first}")
+      end
+
+      def mimetype
+        return inherited_mimetype if @options.nil?
+        @options[:mimetype]
+      end
+
+      alias_method :mime_type, :mimetype
+      def format
+        @options[:format]
+      end
+
+      def name
+        @name
+      end
+
+      alias_method :extension, :name
+
+      def to_sym
+        @name
+      end
+
+      def extension(is_dynamic = false, dynamic_extension = Spontaneous::Output::Template.extension)
+        if (override = @options[:extension])
+          return normalise_extension(override.to_s)
+        end
+        ext =  normalise_extension(name.to_s)
+        ext << ".#{self.dynamic_extension(dynamic_extension)}" if (is_dynamic or self.dynamic?)
+        ext
+      end
+
+      def normalise_extension(ext)
+        ext =  "." << ext unless ext.start_with?(".")
+        ext
+      end
+
+      def dynamic_extension(default_extension)
+        @options[:language] || default_extension
+      end
+
+      def private?
+        @options[:private]
+      end
+
+      def public?
+        !self.private?
+      end
+
+      def dynamic?
+        @options[:dynamic]
+      end
+
+      def postprocess
+        @options[:postprocess]
+      end
+
+      def context
+        Spontaneous::Site.context (helper_formats + [name]).uniq.compact
+      end
+    end
+
+    extend ClassMethods
+    extend Forwardable
+
+    attr_reader :page
+    attr_accessor :content
+
+    def_delegators "self.class", :format, :dynamic?, :extension, :to_sym, :mimetype, :mime_type, :public?, :private?, :context, :name, :extension
+
+    def initialize(page, content = nil)
+      @page, @content = page, content
+      @content ||= page
+    end
+
+    def render(params = {}, *args)
+      render_using(default_renderer, params, *args)
+    end
+
+    def render_using(renderer, params, *args)
+      before_render
+      output = render_page(renderer, params, *args)
+      output = postprocess(output)
+      after_render(output)
+      output
+    end
+
+    def default_renderer
+      Spontaneous::Output.renderer
+    end
+
+    def before_render
+    end
+
+    def after_render(output)
+    end
+
+    def postprocess(output)
+      if (process = self.class.postprocess) && (process.is_a?(Proc))
+        output = process.call(@page, output)
+      end
+      output
+    end
+
+    def render_page(renderer, params = {}, *args)
+      renderer.render(self, params, *args)
+    end
+
+    def publish_page(renderer, revision)
+      rendered = render_using(renderer, {:revision => revision})
+      path = output_path(revision, rendered)
+      File.open(path, 'w') do |file|
+        case rendered
+        when IO
+          IO.copy_stream(rendered, file)
+        else
+          file.write(rendered.to_s)
+        end
+      end
+    end
+
+    def output_path(revision, render)
+      ext = nil
+      template_dynamic = Spontaneous::Output::Template.is_dynamic?(render)
+      path = Spontaneous::Output.output_path(revision, self, template_dynamic)
+
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      path
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'format', '*.rb')].each do |format|
+  require format
+end

data/lib/spontaneous/output/helpers/classes_helper.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Spontaneous::Output::Helpers
+  module ClassesHelper
+    extend self
+
+    def classes(*args)
+      args = args.flatten
+      optional = args.extract_options!
+      optional.each do |class_name, active|
+        args << class_name if active
+      end
+      return "" if args.empty?
+      %(class="#{args.join(" ")}")
+    end
+    Spontaneous::Output::Helpers.register_helper(self, :html)
+  end
+end

data/lib/spontaneous/{render/helpers/html_helper.rb → output/helpers/conditional_comment_helper.rb}

@@ -1,19 +1,9 @@
 # encoding: UTF-8
 
-module Spontaneous::Render::Helpers
-  module HTMLHelper
+module Spontaneous::Output::Helpers
+  module ConditionalCommentHelper
     extend self
 
-    def classes(*args)
-      args = args.flatten
-      optional = args.extract_options!
-      optional.each do |class_name, active|
-        args << class_name if active
-      end
-      return "" if args.empty?
-      %(class="#{args.join(" ")}")
-    end
-
     def ie_only(version = nil)
       ie_conditional_comment(version)
     end
@@ -65,5 +55,6 @@ module Spontaneous::Render::Helpers
       end
     end
 
+    Spontaneous::Output::Helpers.register_helper(self, :html)
   end
 end

data/lib/spontaneous/output/helpers/script_helper.rb

@@ -0,0 +1,73 @@
+# encoding: UTF-8
+
+require 'coffee-script'
+
+module Spontaneous::Output::Helpers
+  module ScriptHelper
+    extend self
+
+    def scripts(*args)
+      scripts = args.flatten
+      options = scripts.extract_options!
+      compress = (live? or (publishing? and options[:force_compression]))
+      return compressed_scripts(scripts) if compress
+      scripts.map { |script| script_tag(script)  }.join("\n")
+    end
+
+    alias_method :script, :scripts
+
+    def script_tag(src)
+      src = "#{src}.js" unless src =~ /\.js$/o
+      %(<script type="text/javascript" src="#{src}"></script>)
+    end
+
+    def convert_coffeescript(url)
+      S::Output::Assets.compile_coffeescript(url)
+    end
+
+    def compressed_scripts(scripts)
+      file_paths = scripts.map { |script| [script, S::Output::Assets.find_file("#{script}.js", "#{script}.coffee")] }
+      invalid, file_paths = file_paths.partition { |url, path| path.nil? }
+
+      tags = []
+      unless file_paths.empty?
+        # in order to compile coffeescript efficiently, avoiding multiple anonymous function wrappers
+        # but keeping the files in the correct order
+        # first partition files into js & coffee groups:
+        types = file_paths.slice_between { |(purl, ppath), (url, path)| File.extname(ppath) != File.extname(path) }
+        # then iterate through each group to concatenate the source into a single string (src)
+        js = types.map { |type|
+          ext = nil
+          src = type.map { |url, path|
+            ext = File.extname(path)
+            File.read(path)
+          }.join
+          # then compile the concatenated src if it's coffeescript
+          case ext
+          when ".coffee"
+            CoffeeScript.compile src
+          else
+            src
+          end
+        }.join
+
+        compressed, hash = compress_js_string(js)
+        output_path = Spontaneous::Output::Assets.path_for(revision, "#{hash}.js")
+
+        FileUtils.mkdir_p(File.dirname(output_path))
+        File.open(output_path, "w") { |file| file.write(compressed) }
+
+        tags = [script_tag(Spontaneous::Output::Assets.url(hash))]
+      end
+
+      tags.concat invalid.map { |src, path| script_tag(src) }
+      tags.join("\n")
+    end
+
+    def compress_js_string(js_string)
+      Spontaneous::Output::Assets::Compression.shine_compress_string(js_string, :js)
+    end
+
+    Spontaneous::Output::Helpers.register_helper(self, :html)
+  end
+end