alula 0.2.3 → 0.4.0b

data/lib/alula/progress.rb

@@ -0,0 +1,95 @@
+require 'alula/progressbar'
+
+module Alula
+  class Progress
+    def initialize(options)
+      @pbars = {}
+      @interval = 1.0
+      @options = options
+      @display = false
+      
+      @@lock = Mutex.new
+    end
+    
+    def create(identifier, opts)
+      if @pbars[identifier]
+        @pbars[identifier].finish
+      end
+      
+      @@lock.synchronize do
+        @pbars[identifier] = ProgressBar.new(opts[:title], opts[:total] == 0 ? 0.1 : opts[:total])
+        if @options[:debug]
+          @pbars[identifier].settings.force_mode = :notty
+        end
+      end
+    end
+    
+    def step(identifier)
+      if @pbars[identifier]
+        @pbars[identifier].step
+        _display
+      end
+    end
+
+    def set(identifier, value)
+      if @pbars[identifier]
+        @pbars[identifier].set(value)
+      end
+    end
+    
+    def title(identifier, title)
+      if @pbars[identifier]
+        @pbars[identifier].message = title
+      end
+    end
+    
+    def set_file_transfer(identifier)
+      if @pbars[identifier]
+        @pbars[identifier].file_transfer_mode
+      end
+    end
+    
+    def finish(identifier)
+      if @pbars[identifier]
+        @pbars[identifier].finish
+        _display
+        @@lock.synchronize do
+          @pbars.delete(identifier)
+        end
+      end
+    end
+    
+    def display
+      @display = true
+      _display(true)
+      unless @options[:debug]
+        @update_thread = Thread.new {
+          loop {
+            sleep(@interval)
+            _display
+          }
+        }
+      end
+    end
+    
+    def hide
+      @display = false
+      if @update_thread
+        Thread.kill(@update_thread)
+      end
+    end
+    
+    private
+    def _display(first = false)
+      return unless @display
+      
+      @@lock.synchronize do
+        output = @pbars.collect {|identifier, pbar| pbar.render }
+        unless @options[:debug] or first
+          print "\e[#{output.count}F"
+        end
+        puts output.join("\n")
+      end
+    end
+  end
+end

data/lib/alula/progressbar.rb

@@ -0,0 +1,66 @@
+require 'powerbar'
+
+module Alula
+  class ProgressBar < PowerBar
+    attr_accessor :showing
+    attr_accessor :message
+    
+    def initialize(message, total, opts = {})
+      super(opts)
+      
+      @message = "%20s" % message
+      @done = 0
+      @total = total
+      
+      @showing = true
+      
+      self.settings.tty.finite.template.main = '${<msg>}: ${<percent>% } ${[<bar>] }${ ETA: <eta>}'
+      self.settings.tty.finite.template.barchar = 'o'
+      self.settings.tty.finite.template.padchar = ' '
+    end
+    
+    def file_transfer_mode
+      self.settings.tty.finite.template.main = '${<msg>}: ${<percent>% } ${[<bar>] }${<rate>/s }${<done>}${ ETA: <eta>}'
+    end
+    
+    def render(opts = {})
+      super({msg: @message, done: @done, total: @total}.merge(opts))
+    end
+    
+    def step
+      @done += 1
+    end
+    
+    def set(value)
+      @done = value
+    end
+    
+    def vanish
+      self.wipe
+    end
+    
+    def finish(fill = true)
+      # self.close(true)
+      render(
+        {
+          :done => fill && !state.total.is_a?(Symbol) ? state.total : state.done,
+          :tty => {
+                    :finite => { :show_eta => false },
+                    :infinite => { :show_eta => false },
+                  },
+          :notty => {
+                    :finite => { :show_eta => false },
+                    :infinite => { :show_eta => false },
+                  },
+        })
+      # scope.output.call(scope.template.close) unless scope.template.close.nil?
+      state.closed = true
+    end
+    
+    private
+    # Monkey-patch to force percentage always being three characters long
+    def h_percent
+      sprintf "%3d", percent
+    end
+  end
+end

data/lib/alula/site.rb

@@ -1,336 +1,405 @@
-require 'yaml'
-require 'jekyll'
-require 'sprockets'
-require 'active_support/inflector/methods'
-require 'progressbar'
-require 'stringex'
-
-require 'alula/theme'
-require 'alula/plugins'
-require 'alula/assethelper'
+require 'alula/core_ext'
 
-# Compressors
+require 'alula/config'
+require 'alula/plugin'
+require 'alula/storage'
+require 'alula/content'
+require 'alula/context'
+require 'alula/generator'
+require 'alula/attachment_processor'
 require 'alula/compressors'
+require 'alula/cdn'
+require 'alula/helpers'
+require 'alula/progress'
+
+require 'thor'
+require 'sprockets'
+require 'i18n'
+require 'parallel'
+require 'hashie/mash'
 
-# Jekyll extensions, plugins, tags
-# These are used always in every blog, i.e. mandatory plugins
-require 'alula/plugins/assets'
-require 'alula/plugins/pagination'
+# Silence Tilt
+require 'sass'
+require 'coffee-script'
 
 module Alula
   class Site
+    def self.instance; @@instance; end
+    
+    # Global configuration
+    attr_reader :config
+    
+    # Storage
+    attr_reader :storage
+    
+    # Context for rendering
+    attr_reader :context
+    
+    # Progress displayer
+    attr_reader :progress
+    
+    # CDN Resolver for Site
+    attr_reader :cdn
+    
+    # Site Plugins
+    attr_reader :plugins
+    
+    # Site filters
+    attr_reader :filters
+    
+    # Compressors
+    attr_reader :compressors
+    
+    # Site metadata information
+    attr_reader :metadata
     
-    attr_reader :config, :jekyll
+    # Site attachment mapping
+    attr_reader :attachments
     
-    def initialize(override = {})
-      # Load configuration
-      @config = YAML.load_file('config.yml').deep_merge(override)
-      
-      # Register local theme path
-      Alula::Theme.register("themes")
-      
-      # Initialize Jekyll
-      options         = Alula::DEFAULTS.deep_merge({
-        # Site options
-        'title'          => @config["title"],
-        'tagline'        => @config["tagline"],
-        'author'         => @config["author"],
-        'root'           => @config["root"],
-        'asset_path'     => File.join(@config["root"], "assets"),
-        'permalink'      => @config["permalink"],
-        'paginate'       => @config["paginate"],
-        'pagination_dir' => @config["pagination_dir"],
-        'excerpt_link'   => @config["excerpt_link"],
+    # Theme
+    attr_reader :theme
+    
+    # User generated content
+    attr_reader :content
+
+    # System generated content, pages, pagination, etc.
+    attr_reader :generated
+    
+    def initialize(options)
+      @@instance = self
+      
+      # Read local config
+      @config = Config.new(options)
+
+      @storage = Storage.load(site: self)
+      
+      @metadata = Content::Metadata.new({
+        base_locale: @config.locale,
+        environment: @config.environment,
+        
+        title: @config.title,
+        author: @config.author,
+        tagline: @config.tagline,
+        url: @config.url,
+        
+        theme: @config.theme,
+        
+        # Use this to store information of GIT site or note
+        git: ::File.directory?(".git"),
       })
       
-      @jekyll = Jekyll::Site.new(options)
+      # Progress displayer
+      @progress = Progress.new(debug: options["debug"])
       
-      @themepath = Alula::Theme.find_theme(@config['theme'])
-      unless @themepath
-        raise "Cannot find theme #{@config['theme']}"
+      # Compressors
+      compressors = if @config.assets.compress
+        {
+          html: Alula::Compressors::HTMLCompressor.new,
+          css: Alula::Compressors::CSSCompressor.new,
+          js: Alula::Compressors::JSCompressor.new,
+        }
+      else
+        {
+          html: Alula::Compressors::DummyCompressor.new,
+          css: Alula::Compressors::DummyCompressor.new,
+          js: Alula::Compressors::DummyCompressor.new,
+        }
       end
+      @compressors = Hashie::Mash.new(compressors)
       
-      # Initialize Sprockets
-      @sprockets = Sprockets::Environment.new
-      # Set our compressor
-      if @config['asset_compress']
-        @sprockets.css_compressor = Alula::Compressors::CSSCompressor.new
-        @sprockets.js_compressor = Alula::Compressors::JSCompressor.new
-        
-        [Jekyll::Post, Jekyll::Page].each do |klass|
-          klass.send(:include, Alula::Compressors::HTMLCompressor)
-          klass.send(:alias_method, :output_without_compression, :output)
-          klass.send(:alias_method, :output, :output_with_compression)
-        end
-      end
-
-      # Add theme to asset paths
-      @sprockets.append_path File.join(@themepath, @config['theme'], "stylesheets")
-      @sprockets.append_path File.join(@themepath, @config['theme'], "javascripts")
-
-      # Generated assets
-      @sprockets.append_path File.join("_tmp", "assets")
+      @attachments = AttachmentProcessor.new(site: self)
       
-      # Attachments
-      @sprockets.append_path File.join("attachments", "_generated")
+      # Set up CDN resolver
+      @cdn = CDN.load(site: self)
       
-      # Vendor assets
-      vendor_path = File.expand_path(File.join(File.dirname(__FILE__), *%w{.. .. vendor}))
-      @sprockets.append_path File.join(vendor_path, "stylesheets")
-      @sprockets.append_path File.join(vendor_path, "javascripts")
+      @plugins = {}
+      
+      @filters = {}
+      
+      # Set up I18n
+      l10n_path = File.join(File.dirname(__FILE__), "..", "..", "locales", "l10n", "*.yml")
+      locale_path = File.join(File.dirname(__FILE__), "..", "..", "locales", "*.yml")
+      custom_locale_path = File.join(@storage.path(:custom, "locales"), "*.yml")
+      I18n.load_path += Dir[l10n_path]
+      I18n.load_path += Dir[locale_path]
+      I18n.load_path += Dir[custom_locale_path]
+      I18n.default_locale = @config.locale
+      
+      # Set up default head addons
+      Alula::Plugin.addon(:head, "<meta name=\"generator\" content=\"Alula #{Alula::VERSION}\">")
+      Alula::Plugin.addon(:head, ->(context){"<link rel=\"icon\" type=\"image/png\" href=\"#{context.asset_url('favicon.png')}\">"})
       
-      # Initialize blog plugins
-      if @config["plugins"] != nil
-        @config["plugins"].each do |plugin, opts|
-          require "alula/plugins/#{plugin}"
-        
-          plugin_class = Alula::Plugins.const_get(ActiveSupport::Inflector.camelize(plugin, true))
-          path = plugin_class.install(opts)
-          @sprockets.append_path File.join(path, "stylesheets")
-          @sprockets.append_path File.join(path, "javascripts")
-        end
-      end
     end
     
+    # Compiles a site to static website
     def generate
-      puts "==> Generating blog"
+      # Load our plugins and filters
+      load_plugins
+      load_filters
+      
+      # Prepare public folder
+      prepare(true)
       
-      # Prepare Jekyll environment
-      prepare
+      load_content
       
-      # Generate missing assets
-      assetgen
+      process_attachments
       
-      # Generate asset manifest
-      compile
+      compile_assets
       
-      # Execute jekyll
-      process
+      render
       
-      # Cleanup
       cleanup
+      # Store cached version of configuration
+      cached_config = File.join(storage.path(:cache), "config.yml")
+      @config.write_cache(cached_config)
     end
     
-    def preview
-      generate
-      
-      require 'webrick'
-        # include WEBrick
-
-        FileUtils.mkdir_p("public")
-
-        mime_types = WEBrick::HTTPUtils::DefaultMimeTypes
-        mime_types.store 'js', 'application/javascript'
-
-        s = WEBrick::HTTPServer.new(
-          :Port            => 3000,
-          :MimeTypes       => mime_types
-        )
-        s.mount('/', WEBrick::HTTPServlet::FileHandler, "public")
-        t = Thread.new {
-          s.start
-        }
-
-        trap("INT") { s.shutdown }
-        t.join()
+    # Proxy to metadata
+    def method_missing(meth, *args, &blk)
+      # Proxy to metadata
+      if !meth[/=$/] and self.metadata.respond_to?(meth)
+        args.unshift(self.context.locale || self.config.locale) if args.empty?
+        self.metadata.send(meth, *args)
+      else
+        super
+      end
     end
     
-    def asset_attach(a_post, assets)
-      # Find the post
-      post = find_post(a_post) or raise "Cannot find post #{a_post}"
-      
-      /(?<date>(\d{4}-\d{2}-\d{2}))/ =~ post
-      date = Time.parse(date)
-      asset_path = File.join(%w{%Y %m %d}.collect{|f| date.strftime(f) })
-      
-      helper = Alula::AssetHelper.new(asset_path, @config)
-      
-      post_io = File.open(post, "a")
-      assets.each do |asset|
-        type, generated = helper.process(asset, :type => :attachment)
-        tn_type, tn_generated = helper.process(asset, :type => :thumbnail)
-        if generated and tn_generated
-          # Asset processed
-          puts "(#{asset}) done."
-          if handler = Alula::Plugins.attachment_handler(type)
-            post_io.puts handler.call(generated[0])
-          else
-            post_io.puts "{% image _images/#{generated[0]} %}"
-          end
-        else
-          puts "(#{asset}) cannot process."
+    private
+    def load_plugins
+      config.plugins.each do |name, options|
+        if plugin = Alula::Plugin.load(name, options)
+          @plugins[name] = plugin
         end
       end
     end
     
-    def clean
-      cleanup
-      FileUtils.rm_rf(Dir[File.join("attachments", "_images", "*")])
-      FileUtils.rm_rf(Dir[File.join("attachments", "_thumbnails", "*")])
+    def load_filters
+      config.content.filters.each do |name, options|
+        if filter = Alula::Filter.load(name, options)
+          @filters[name] = filter
+        end
+      end
     end
     
-    private
-    def find_post(post)
-      if File.exists?(post)
-        return post
-      elsif File.exists?(File.join("posts", post))
-        return File.join("posts", post)
-      else
-        # Try to find by title
-        title = post.to_url
-        posts = Dir[File.join("posts", "*")].select { |p| p =~ /#{title}/ }
-        if posts.count == 1
-          return posts.first
+    def prepare(preserve = false)
+      say "==> Preparing environment" + (preserve ? " (preserving existing files)" : "")
+      
+      # Delegate preparations to storage module
+      self.storage.prepare(preserve)
+      
+      # Load theme
+      @context = Alula::Context.new(site: self, storage: self.storage)
+      @context.send(:extend, Helpers)
+      
+      @theme = Alula::Theme.load(site: self)
+      
+      # Create our asset environment
+      @environment = Environment.new
+      # Add compressor support
+      # if config.environment == "production"
+      @environment.css_compressor = @compressors.css
+      @environment.js_compressor = @compressors.js
+      # end
+      @environment.context_class.class_eval do
+        # include Helpers
+        def context; Alula::Site.instance.context; end
+        def method_missing(meth, *args, &blk)
+          return context.send(meth, *args, &blk) if context.respond_to?(meth)
+          super
         end
       end
+      @context.environment = @environment
+      @context.attachments = self.attachments
+      
+      # Add generated attachements
+      @environment.append_path @storage.path(:cache, "attachments")
+      
+      # Add generated assets
+      @environment.append_path @storage.path(:cache, "assets")
+      
+      # Theme, plugins, vendor and customisation
+      [
+        self.theme.path,
+        *plugins.collect{|name, plugin| plugin.asset_path},
+        ::File.join(File.dirname(__FILE__), "..", "..", "vendor"),
+      ].each do |path|
+        %w{javascripts stylesheets images}.each {|p|
+          @environment.append_path ::File.join(path, "assets", p)
+        }
+      end
+      
+      # Customisation
+      %w{javascripts stylesheets images}.each do |path|
+        @environment.prepend_path @storage.path(:custom, path)
+      end
     end
     
-    def prepare
-      puts "==> Prepare"
-      # Clean our temporary folder
-      FileUtils.rm_rf "_tmp"
-      FileUtils.mkdir "_tmp"
-      FileUtils.rm_rf "public"
-      FileUtils.mkdir "public"
-      
-      # Copy Jekyll files
-      # Install our theme
-      FileUtils.mkdir_p File.join("_tmp", "_layouts")
-      FileUtils.mkdir_p File.join("_tmp", "_includes")
-
-      FileUtils.cp_r Dir[File.join(@themepath, @config['theme'], "layouts", "*")], File.join("_tmp", "_layouts")
-      FileUtils.cp_r Dir[File.join(@themepath, @config['theme'], "includes", "*")], File.join("_tmp", "_includes")
-
-      FileUtils.cp_r Dir[File.join(@themepath, @config['theme'], "site", "*")], "_tmp"
-      
-      # Copy posts
-      FileUtils.mkdir_p File.join("_tmp", "_posts")
-      FileUtils.cp_r Dir[File.join("posts", "*")], File.join("_tmp", "_posts")
+    def load_content
+      say "==> Loading site content"
       
-      # Copy pages
-      Dir[File.join("pages", "**", "*")].each do |page|
-        next unless File.file?(page)
-        page = File.join(page.split("/")[1..-1])
-        
-        FileUtils.mkdir_p File.join("_tmp", File.dirname(page))
-        FileUtils.cp File.join("pages", page), File.join("_tmp", page)
+      # Read site content
+      @content = Content.new(site: self)
+      @content.load
+
+      # Do we have index page defined
+      if self.config.index
+        index_page = @content.by_slug(self.config.index)
+        if index_page
+          index_page.metadata.slug = "index"
+          index_page.metadata.template = "/:locale/:slug"
+          index_page.metadata.title = Hash[index_page.metadata.languages.collect{|lang| [lang, metadata.title(lang)]}]
+        end
       end
-      
-      FileUtils.mkdir_p File.join("_tmp", "assets")
     end
     
-    def assetgen
-      puts "==> Generating assets"
-      
-      # width, height = @config["images"]["thumbnails"].split("x").collect {|i| i.to_i }
+    def process_attachments
+      puts "==> Processing attachments"
       
-      # Get all attachements
-      attachments_path = File.join("attachments", "originals")
-      images_path = File.join("attachments", "_generated", "images")
-      thumbnails_path = File.join("attachments", "_generated", "thumbnails")
+      progress.create :attachments, title: "Attachments", total: self.content.attachments.count
+      progress.display
       
-      attachments = Dir[File.join(attachments_path, "**", "*")]
-        .select {|f| File.file?(f) }
-        .collect {|f| File.join(f.split("/")[2..-1])}
-      pb = ProgressBar.new "Assets", attachments.count
+      @@lock = Mutex.new
       
-      attachments.each do |attachment|
-        unless File.exists?(File.join(images_path, attachment))
-          helper = Alula::AssetHelper.new(File.dirname(attachment), @config)
-          type, generated = helper.process(File.join("attachments", "originals", attachment), :type => :attachment)
+      Parallel.map(self.content.attachments, :in_threads => Parallel.processor_count) do |attachment|
+        if processor = attachments.get(attachment)
+          processor.process
         end
-        
-        unless File.exists?(File.join(thumbnails_path, attachment))
-          helper = Alula::AssetHelper.new(File.dirname(attachment), @config)
-          tn_type, tn_generated = helper.process(File.join("attachments", "originals", attachment), :type => :thumbnail)
+        @@lock.synchronize do
+          progress.step(:attachments)
         end
-        
-        pb.inc
       end
-
-      pb.finish
+      
+      progress.finish(:attachments)
+      progress.hide
+      
+      # DEBUG
+      require 'json'
+      File.open(self.storage.path(:cache) + "/mapping.json", 'w') {|io| io.puts self.attachments.mapping.to_json}
     end
     
-    def compile
+    def compile_assets
       puts "==> Compiling assets"
       
-      # Package stylesheet
-      File.open(File.join("_tmp", "assets", "styles.css"), "w") do |tf|
-        tf.puts "/*"
-        tf.puts " *=require #{@config["theme"]}"
+      # Generate stylesheet
+      @storage.output(:cache, "assets/style.css") do |io|
+        io.puts "/*"
+        
+        # Theme style
+        io.puts " *= require #{self.config.theme}"
+        
         # Plugins
-        if @config["plugins"]
-          @config["plugins"].each { |plugin, opts| tf.puts " *=require #{plugin}" }
+        @plugins.each do |name, plugin|
+          io.puts " *= require #{name}"
+        end
+        
+        # Vendored
+
+        # Blog customization
+        @storage.custom(/stylesheets\/.*.css.*$/).each do |name, item|
+          name = File.basename(name).gsub(/(\.\S+)$/, '')
+          io.puts " *= require #{name}"
         end
-        tf.puts " */"
+        
+        io.puts "*/"
       end
+      # Add stlesheet to template
+      Alula::Plugin.addon(:head, ->(context){ context.stylesheet_link("style") })
       
-      # Package javascript
-      File.open(File.join("_tmp", "assets", "scripts.js"), "w") do |tf|
-        tf.puts "//=require #{@config["theme"]}"
+      # Generate javascript
+      @storage.output(:cache, "assets/script.js") do |io|
+        io.puts "/*"
+
+        # Theme scripts
+        io.puts " *= require #{self.config.theme}"
+
         # Plugins
-        if @config["plugins"]
-          @config["plugins"].each { |plugin, opts| tf.puts "//=require #{plugin}" }
+        @plugins.each do |name, plugin|
+          io.puts " *= require #{name}"
         end
-      end
 
-      File.open(File.join("_tmp", "assets", "scripts_body.js"), "w") do |tf|
-        tf.puts "//=require #{@config["theme"]}_body"
-        # Plugins
-        if @config["plugins"]
-          @config["plugins"].each { |plugin, opts| tf.puts "//=require #{plugin}_body" }
+        # Vendored
+        io.puts " *= require lazyload" if self.config.attachments.image.lazyload
+
+        # Customisation
+        @storage.custom(/javascripts\/.*.js.*$/).each do |name, item|
+          name = File.basename(name).gsub(/(\.\S+)$/, '')
+          io.puts " *= require #{name}"
         end
+        io.puts " */"
       end
+      # Add javascript to end of body
+      Alula::Plugin.addon(:body, ->(context){ context.javascript_link("script") })
       
+      # Compile all assets
+      progress.create :assets, title: "Compiling assets", total: @environment.each_logical_path.count
+      progress.display
+      
+      @manifest = Manifest.new(@environment, @storage.path(:assets))
+      @manifest.progress = -> { progress.step(:assets) }
       
-      @manifest = Sprockets::Manifest.new(@sprockets, File.join("public", "assets"))
-
-      # Compile assets
       @manifest.compile
-      # @manifest.compile([
-      #   # Stylesheet
-      #   "styles.css",
-      #   
-      #   # Javascript
-      #   "javascripts.js",
-      #   
-      #   # Attachments
-      #   Dir[File.join("attachments", "**", "*")]
-      #     .select {|f| File.file?(f) }
-      #     .collect {|f| File.join(f.split("/")[1..-1])},
-      # ])
-      
-      # Inject our manifest to jekyll
-      @jekyll.config["manifest"] = @manifest
-      
-      # Cleanup
-      %w{styles.css scripts.js scripts_body.js}.each do |f|
-        FileUtils.rm(File.join("_tmp", "assets", f))
-      end
+
+      progress.finish(:assets)
+      progress.hide
     end
     
-    def process
-      puts "==> Processing Jekyll site"
-      
-      @jekyll.reset
-      @jekyll.read
-      @jekyll.generate
-      @jekyll.render
-      @jekyll.write
+    def render
+      say "==> Render site"
+      
+      progress.create :render, title: "Rendering content", total: (self.content.posts.count + self.content.pages.count)
+      progress.display
+      
+      # Render all user content, parallel...
+      (self.content.posts + self.content.pages).each do |content|
+        # Write content to file
+        content.write
+        
+        progress.title(:render, "%20s" % content.name[0..19]) if self.config.debug
+        progress.step(:render)
+      end
+      
+      progress.finish(:render)
+      
+      # Copy static content
+      progress.create :static, title: "Copy statics", total: self.content.statics.count
+      self.content.statics.each do |static|
+        @storage.output_public(static.name) { |io| io.write(static.read) }
+        
+        progress.step :static
+      end
+      progress.finish :static
+      
+      progress.hide
     end
     
     def cleanup
-      puts "==> Cleaning up"
+      say "==> Cleaning up"
+      
+      asset_path = @storage.path(:assets)
+      assets = @environment.used
+        .collect{|u| @environment[u]}
+        .reject{|u| u.nil?}
+        .collect{|u| File.join(asset_path, u.digest_path)}
+      outputted = @storage.outputted.reject{|o|o[/^#{asset_path}/]}
+      
+      keep = assets + outputted
+      Dir[File.join(@storage.path(:public), "**", "*")].each do |entry|
+        next unless File.file?(entry)
+        FileUtils.rm entry if File.file?(entry) and !keep.include?(entry)
+      end
       
-      FileUtils.rm_rf "_tmp"
+      # Clean up empty directories
+      Dir[File.join(@storage.path(:public), "**", "*")].each do |entry|
+        next unless File.directory?(entry)
+        FileUtils.rmdir entry if Dir[File.join(entry, "**", "*")].count == 0
+      end
     end
-  end
-  
-  DEFAULTS = Jekyll::DEFAULTS.deep_merge({
-    'source'      => '_tmp',
-    'destination' => 'public',
-    'markdown'    => 'kramdown',
     
-    'pagination_dir' => '/page/',
-  })
+    # Output helpers
+    def say(msg)
+      @shell ||= Thor::Shell::Basic.new
+      @shell.say msg
+    end
+  end
 end