gumdrop 0.7.5 → 0.8.0

data/lib/gumdrop/server.rb

@@ -5,18 +5,18 @@ require 'logger'
 
 module Gumdrop
 
-  STATIC_ASSETS= %w(.jpg .jpe .jpeg .gif .ico .png)
+  STATIC_ASSETS= %w(.jpg .jpe .jpeg .gif .ico .png .swf)
 
   class Server < Sinatra::Base
-    site_file= Gumdrop.fetch_site_file
-    unless site_file.nil?
-      site= Site.new site_file
+    site= Gumdrop.fetch_site
+
+    unless site.nil?
       site.rescan()
 
       set :port, site.config.server_port if site.config.server_port
       
       if site.config.proxy_enabled
-        require 'gumdrop/proxy_handler'
+        require 'gumdrop/support/proxy_handler'
         get     '/-proxy/*' do handle_proxy(params, env) end
         post    '/-proxy/*' do handle_proxy(params, env) end
         put     '/-proxy/*' do handle_proxy(params, env) end

data/lib/gumdrop/site.rb

@@ -17,10 +17,14 @@ module Gumdrop
   }
 
   class Site
+
+    extend Support::Callbacks
     
     attr_reader :opts,
                 :root_path, 
                 :src_path,
+                :out_path,
+                :data_path,
                 :blacklist,
                 :greylist,
                 :redirects,
@@ -34,15 +38,15 @@ module Gumdrop
                 :content_hash,
                 :last_run
 
-    extend Callbacks
-
     callbacks :on_start, 
               :on_before_scan,
               :on_scan, 
               :on_before_generate,
               :on_generate, 
               :on_before_render,
-              :on_render, 
+              :on_render,
+              :on_before_render_item,
+              :on_render_item,
               :on_end
 
     def initialize(sitefile, opts={})
@@ -53,11 +57,15 @@ module Gumdrop
       reset_all()
     end
 
+    def opts=(opts={})
+      @opts= opts
+    end
+
     def contents(*args)
       opts= args.extract_options!
       pattern= args.first || nil
 
-      if pattern.nil?
+      if pattern.nil? or pattern.empty?
         if opts[:as] == :hash
           @content_hash
         else
@@ -65,17 +73,19 @@ module Gumdrop
         end
       
       else
-        nodes = opts[:as] == :hash ? {} : []
-        @content_hash.keys.each do |path|
-          if path_match path, pattern
-            if opts[:as] == :hash
-              nodes[path]= @content_hash[path]
+        if pattern.is_a? Array
+          nodes= opts[:as] == :hash ? {} : []
+          pattern.each do |subpattern|
+            if opts[:as]== :hash
+              nodes.merge! match_nodes(subpattern, opts)
             else
-              nodes << @content_hash[path]
+              nodes << match_nodes(subpattern, opts)
             end
           end
+          opts[:as]== :hash ? nodes : nodes.flatten
+        else
+          match_nodes(pattern, opts)
         end
-        nodes
       end
     end
 
@@ -89,23 +99,36 @@ module Gumdrop
       self
     end
 
-    def build
+    def build(force_reset=false)
       on_start(self)
+      report "[#{ Time.new }]"
+      reset_all() if force_reset
       scan()
       render()
       @last_run= Time.now
       on_end(self)
+      report "[Done]"
       self
     end
+    
+    def rebuild
+      build true
+    end
 
     def report(msg, level=:info)
       case level
         when :info
-          @log.info msg
-        when :warning
+          unless @opts[:quiet]
+            if @opts[:subdued]
+              print "."
+            else
+              @log.info msg 
+            end
+          end
+        when :warning, :warn
           @log.warn msg
       else
-        puts msg
+        print "!" if @opts[:subdued]
         @log.error msg
       end
     end
@@ -137,12 +160,13 @@ module Gumdrop
       @greylist        = []
       @redirects       = []
 
-      @content_hash       = Hash.new {|h,k| h[k]= nil }
+      @content_hash    = Hash.new {|h,k| h[k]= nil }
       @layouts         = Hash.new {|h,k| h[k]= nil }
       @partials        = Hash.new {|h,k| h[k]= nil }
       @generators      = Hash.new {|h,k| h[k]= nil }
       
       @config          = Gumdrop::Config.new DEFAULT_OPTIONS
+      @config.env      = @opts[:env] if @opts.has_key? :env
 
       clear_on_start()
       clear_on_before_scan()
@@ -151,6 +175,8 @@ module Gumdrop
       clear_on_generate()
       clear_on_before_render()
       clear_on_render()
+      clear_on_before_render_item()
+      clear_on_render_item()
       clear_on_end()
 
       load_sitefile()
@@ -164,20 +190,35 @@ module Gumdrop
       init_logging()
     end
 
+    def match_nodes(pattern, opts={})
+      nodes = opts[:as] == :hash ? {} : []
+      @content_hash.keys.each do |path|
+        if path_match path, pattern
+          if opts[:as] == :hash
+            nodes[path]= @content_hash[path]
+          else
+            nodes << @content_hash[path]
+          end
+        end
+      end
+      nodes
+    end
+
     def init_logging
       begin
         @log = Logger.new @config.log, 'daily'
       rescue
-        target= if @opts[:quiet] or @opts[:quiet_given]
+        target= if @opts[:quiet]
           nil
         else
           STDOUT
         end
         @log = Logger.new target
-        report "Using STDOUT for logging because of exception: #{ $! }" unless target.nil?
+        # report "Using STDOUT for logging because of exception: #{ $! }" unless target.nil?
       end
       @log.formatter = proc do |severity, datetime, progname, msg|
-        "#{datetime}: #{msg}\n"
+        # "#{datetime}: #{msg}\n"
+        "  #{msg}\n"
       end
     end
 
@@ -252,20 +293,35 @@ module Gumdrop
       unless opts[:dry_run]
         report "[Compiling to #{@out_path}]", :info
         on_before_render(self)
-        @content_hash.keys.sort.each do |path|
-          node= @content_hash[path]
-          unless node.ignore?
-            output_path= File.join(@out_path, node.to_s)
-            FileUtils.mkdir_p File.dirname(output_path)
-            node.renderTo render_context, output_path, content_filters
-          else
-            report "  ignoring: #{node.to_s}", :info
-          end
+        nodes= if opts[:assets]
+          contents(opts[:assets])
+        else
+          contents()
+        end
+        nodes.each do |node|
+          render_content(node, render_context, content_filters)
         end
         on_render(self)
       end
     end
 
+    def render_content(node, ctx, filters)
+      unless node.ignore?
+        output_path= File.join(@out_path, node.to_s)
+        FileUtils.mkdir_p File.dirname(output_path)
+        begin
+          on_before_render_item(self, node)
+          node.renderTo ctx, output_path, filters
+          on_render_item(self, node)
+        rescue => ex
+          report "[!>EXCEPTION<!]: #{ node.to_s }", :error
+          report [ex.to_s, ex.backtrace].flatten.join("\n"), :error
+          exit 1 unless @opts[:resume]
+        end
+      else
+        report "  ignoring: #{ node.to_s }", :info
+      end
+    end
   end
 
   class Sitefile
@@ -305,6 +361,10 @@ module Gumdrop
         @site.config.instance_eval &block
       end
     end
+
+    def tasks(&block)
+      Gumdrop::CLI::Internal.class_eval &block
+    end
     
     # Callbacks
     def on_start(&block)
@@ -328,6 +388,12 @@ module Gumdrop
     def on_render(&block)
       @site.on_render &block
     end
+    def on_before_render_item(&block)
+      @site.on_before_render &block
+    end
+    def on_render_item(&block)
+      @site.on_render &block
+    end
     def on_end(&block)
       @site.on_end &block
     end

data/lib/gumdrop/support/base_packager.rb

@@ -0,0 +1,60 @@
+module Gumdrop
+  module Support
+    module BasePackager
+
+      def compress_output(content, opts)
+        case opts[:compress]
+
+        when true, :jsmin
+          require 'jsmin'
+          JSMin.minify content
+
+        when :yuic
+          require "yui/compressor"
+          compressor = YUI::JavaScriptCompressor.new(:munge => opts[:obfuscate])
+          compressor.compress(content)
+
+        when :uglify
+          require "uglifier"
+          Uglifier.compile( content, :mangle=>opts[:obfuscate])
+
+        when :packr
+          require 'packr'
+          Packr.pack(content, :shrink_vars => true, :base62 => false, :private=>false)
+
+        when false
+          content
+
+        else
+          # UNKNOWN Compressor type!
+          @site.report "Unknown javascript compressor type! (#{ opts[:compressor] })", :warning
+          content
+        end
+      end
+      
+      def keep_src(name, content, opts)
+        if opts[:keep_src] or opts[:keep_source]
+          ext= File.extname name
+          page name.gsub(ext, "#{opts.fetch(:source_postfix, '-src')}#{ext}") do
+            content
+          end
+        end
+      end
+      
+      def prune_src(name, opts)
+        if opts[:prune] and opts[:root]
+          sp = File.expand_path( @site.config.source_dir )
+          rp = File.expand_path(opts[:root])
+          relative_root = rp.gsub(sp, '')[1..-1]
+          rrlen= relative_root.length - 1
+          @site.content_hash.keys.each do |path|
+            if path[0..rrlen] == relative_root and name != path
+              @site.content_hash.delete path
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/gumdrop/{callbacks.rb → support/callbacks.rb}

@@ -1,4 +1,4 @@
-module Gumdrop
+module Gumdrop::Support
   module Callbacks
     
     # For defining callbacks

data/lib/gumdrop/support/sprockets.rb

@@ -0,0 +1,34 @@
+# sprockets.rb
+begin
+  require 'sprockets'
+  has_sprockets= true
+rescue LoadError
+  has_sprockets= false
+end
+
+module Gumdrop::Support
+
+  module Sprockets # mixes in to generator
+    include BasePackager
+    
+    def sprockets(name, opts)
+      if has_sprockets
+        env = Sprockets::Environment.new @site.root_path
+        env.append_path @site.src_path
+        opts[:paths].each do |path|
+          env.append_path(path)
+        end
+        content= env[ opts[:src] ].to_s
+        page name do
+          compress_output(content, opts)
+        end
+        keep_src(name, content, opts)
+        prune_src(name, opts)
+      else
+        throw "Sprockets can't be loaded. Please add it to your Gemfile."
+      end
+    end
+
+  end
+
+end

data/lib/gumdrop/support/stitch.rb

@@ -0,0 +1,144 @@
+# stitch.rb
+begin
+  require 'stitch-rb'
+  has_stitch= true
+rescue LoadError
+  has_stitch= false
+end
+
+module Gumdrop::Support
+
+  module Stitch # mixes in to generator
+    include BasePackager
+
+    def stitch(name, opts)
+      if has_stitch
+        content= Stitch::Package.new(opts).compile
+        page name do
+          compress_output(content, opts)
+        end
+        keep_src(name, content, opts)
+        prune_src(name, opts)
+      else
+        throw "Stitch can't be loaded. Please add it to your Gemfile."
+      end
+    end
+
+  end
+
+end
+
+if defined?(Stitch)
+
+  class Stitch::Source
+    # Patch for gumdrop style filenames
+    def name
+      name = path.relative_path_from(root)
+      name = name.dirname + name.basename(".*")
+      name.to_s.gsub(".js", '')
+    end
+  end
+
+
+  # Custom Compilers
+
+
+  class SerenadeCompiler < Stitch::Compiler
+    
+    extensions :serenade
+    
+    def compile(path)
+      content= File.read(path)
+      viewname= File.basename(path).gsub('.serenade', '').gsub('.html', '').gsub('.', '_')
+      %{
+        Serenade.view(#{ viewname.to_json }, #{content.to_json});
+      }
+    end
+    
+  end
+
+  # Not so sure on this one...
+  class HoganCompiler < Stitch::Compiler
+    # List of supported extensions
+    extensions :mustache
+
+    # A compile method which takes a file path,
+    # and returns a compiled string
+    def compile(path)
+      content = File.read(path)
+      %{
+        var template = Hogan.compile(#{content.to_json});
+        module.exports = (function(data){ return template.render(data); });
+      }
+    end
+  end
+
+  module CssJsCode
+    
+    def export_js_code(path)
+      content= File.read(path)
+      %{
+        var css = #{ transpile(content, File.extname(path)).to_json },
+            node = null;
+        module.exports= {
+          content: css,
+          add: function(to){
+            if(node != null) return;
+            if(to == null) to= document.getElementsByTagName('HEAD')[0] || document.body;
+            node= document.createElement('style');
+            node.innerHTML= css;
+            to.appendChild(node);
+            return this;
+          },
+          remove: function() {
+            if(node != null) {
+              node.parentNode.removeChild(node);
+              node = null;
+            }
+            return this;
+          }
+        };
+      }
+    end
+
+    def transpile(content, ext)
+      content
+    end
+
+  end
+
+  class CssCompiler < Stitch::Compiler
+    include CssJsCode
+
+    extensions :css
+
+    def compile(path)
+      export_js_code path
+    end
+
+  end
+
+
+  begin
+    require 'sass'
+
+    class SassCompiler < Stitch::Compiler
+      include CssJsCode
+
+      extensions :sass, :scss
+
+      def compile(path)
+        export_js_code path
+      end
+
+      def transpile(content, ext)
+        type = (ext == '.sass') ? :sass : :scss
+        Sass::Engine.new(content, :syntax=>type).render
+      end
+    end
+
+  rescue
+    # Sass Not available
+  end
+
+end