tdreyno-staticmatic 2.0.3

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (C) 2008 Stephen Bartholomew
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rubygems' 
+require 'spec'
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/bin/staticmatic

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/staticmatic'
+
+directory = ARGV[0]
+
+if !directory
+  puts "Usage: #{$0} <directory>"
+  exit
+end
+
+StaticMatic::Creator.setup(directory)

data/lib/staticmatic/actionpack_support/mime.rb

@@ -0,0 +1,5 @@
+module Mime
+  CSS  = "text/css"
+  HTML = "text/html"
+  JS   = "text/javascript"
+end

data/lib/staticmatic/actionpack_support/remove_partial_benchmark.rb

@@ -0,0 +1,6 @@
+# Remove ActionController::Base.benchmark call
+class ActionView::PartialTemplate
+  def render
+    @handler.render(self)
+  end
+end

data/lib/staticmatic/autoload.rb

@@ -0,0 +1,18 @@
+module StaticMatic
+  autoload :Builder,     'staticmatic/builder'
+  autoload :Creator,     'staticmatic/creator'
+  autoload :Config,      'staticmatic/config'
+  autoload :Deprecation, 'staticmatic/deprecation'
+  autoload :Previewer,   'staticmatic/previewer'
+  autoload :Rescue,      'staticmatic/rescue'
+  
+  module Helpers
+    autoload :AssetTagHelper,    'staticmatic/helpers/asset_tag_helper'
+    autoload :DeprecatedHelpers, 'staticmatic/helpers/deprecated_helpers'
+    autoload :PageHelper,        'staticmatic/helpers/page_helper'
+    autoload :UrlHelper,         'staticmatic/helpers/url_helper'
+  end
+end
+
+require 'staticmatic/actionpack_support/mime'
+require 'staticmatic/actionpack_support/remove_partial_benchmark'

data/lib/staticmatic/base.rb

@@ -0,0 +1,171 @@
+module StaticMatic
+  class Base
+    include StaticMatic::Rescue
+    include StaticMatic::Deprecation
+    
+    attr_accessor :logger
+    attr_accessor :root_dir
+    attr_accessor :build_dir
+    attr_accessor :src_dir
+    attr_accessor :template
+    attr_accessor :request
+    
+    def initialize(root_dir)
+      @root_dir = root_dir
+      @src_dir = "#{@root_dir}/src"
+      @build_dir = "#{@root_dir}/build"
+      load_helpers
+      initialize_config
+      initialize_logger
+      initialize_template
+    end
+    
+    def initialize_config
+      StaticMatic::Config.setup
+      config_file = File.join(@root_dir, "config.rb")
+      require config_file if File.exists? config_file
+      
+      Haml::Template.options = StaticMatic::Config[:haml_options] if defined?(Haml::Template)
+    end
+    
+    def initialize_logger
+      @logger = Logger.new($stderr)
+      @logger.level = Logger::INFO
+      @logger
+    end
+
+    def initialize_template
+      @template = ActionView::Base.new([], {}, self)
+      @template.template_format = :html
+      @template.finder.view_paths = [@src_dir]
+      @template.instance_variable_set("@staticmatic", self)
+    end
+    
+    def render(template, options = {})
+      @template.template_format = determine_format_for(template)
+      template = strip_extension(template)
+      
+      begin
+        @template.render_file(full_template_path(template), true)
+      rescue Exception => e
+        rescue_from_error(e)
+      end
+    end
+    
+    # Render the given template within the current layout
+    def render_with_layout(template)
+      @template.instance_variable_set("@relative_path_to_root", "#{calculate_relative_path_to_root(full_template_path(template))}")
+      content_for_layout = render(template)
+      
+      @template.instance_variable_set("@current_page", template)
+      @template.instance_variable_set("@content_for_layout", content_for_layout)
+      
+      layout = @template.instance_variable_get("@layout")
+      
+      # Clean @layout variable for next request
+      @template.instance_variable_set("@layout", nil)
+      
+      layout ||= determine_default_layout
+      
+      render("layouts/#{layout}")
+    end
+    
+    # Load all helpers from src/helpers/
+    def load_helpers
+      Dir["#{@src_dir}/helpers/**/*_helper.rb"].each do |helper|
+        load helper
+        module_name = File.basename(helper, '.rb').gsub(/(^|\_)./) { |c| c.upcase }.gsub(/\_/, '')
+        ActionView::Base.class_eval("include #{module_name}")
+      end
+    end
+    
+    # Return the source directory for a given template
+    #
+    # Default is pages/
+    #
+    def template_directory_for(template)
+      template_directory = "pages"
+      
+      %w(stylesheets layouts).each do |directory|
+        template_directory = "" if template.match(/^(\/)?#{directory}/)
+      end
+      
+      template_directory
+    end
+    
+    # Return the format for a given template path 
+    #
+    # For example: application.css.sass -> :css
+    #
+    def determine_format_for(template)
+      ext_matches = template.match /\.([a-z0-9]+)/
+      
+      # For templates that have only handler extensions, default for backwards compatibility
+      if ext_matches
+        unless template.match(/\.([a-z0-9]+)\./)
+          case ext_matches[1]
+          when "sass"
+            extension = :css
+          when "haml"
+            extension = :html
+          end
+        end
+        
+        extension = ext_matches[1].to_sym unless extension
+      else
+        extension = :html
+      end
+      
+      extension
+    end 
+    
+    # Default layout is 'site' but we'll also accept 'application'
+    def determine_default_layout
+      layout = "site"
+      
+      Dir["#{@src_dir}/layouts/**"].each do |layout_file|
+        layout = "application" if layout_file.match /application/
+      end
+      
+      layout 
+    end
+    
+    # Remove the extension from a given template path
+    def strip_extension(template)
+      template.gsub(File.extname(template), '')
+    end
+    
+    # Checks to see if a template exists within a given path 
+    #
+    # Current only used by the previewer as ActionView handles the actual checking
+    def can_render?(template)
+      @template.template_format = determine_format_for(template)
+      template = strip_extension(template)
+      @template.finder.class.reload!
+      @template.finder.file_exists?(full_template_path(template))
+    end
+    
+    # Adds 'index' to a given template path if the path is a directory
+    # Will render as path/index.html
+    #
+    def add_index_if_needed(template)
+      File.directory?(File.join(File.expand_path(@src_dir), template)) ?
+        File.join(template, "index") :
+        template
+    end
+    
+    # Full path to a template, relative to src/
+    def full_template_path(template)
+      add_index_if_needed(File.join(template_directory_for(template), template))
+    end
+    
+    def calculate_relative_path_to_root(template)
+      if template.match(/^((\.\.?)?\/|\#|.+?\:)/) == nil
+        current_page_depth = template.split('/').length - 2;
+        (current_page_depth > 0) ? ([ '..' ] * current_page_depth).join('/') + '/' : ''
+      else
+        ''
+      end
+    end    
+  end
+end

data/lib/staticmatic/builder.rb

@@ -0,0 +1,102 @@
+module StaticMatic
+  class Builder
+    attr_accessor :staticmatic
+    
+    def initialize(staticmatic)
+      @staticmatic = staticmatic
+      determine_last_build 
+      build_pages
+      log_version 
+    end
+    
+    def determine_last_build
+      versions_file = @staticmatic.root_dir + "/builds"
+      @last_build   = File.read(versions_file).split(/\n/)[0] if File.exists?(versions_file)
+    end
+    
+    def log_version
+      return unless StaticMatic::Config[:use_build_tracking]
+      timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      versions_file = @staticmatic.root_dir + "/builds"
+      
+      if File.exists?(versions_file)
+        current_versions = File.read(versions_file)
+        
+        File.open(versions_file, "w") do |file|
+          file.puts timestamp
+          file.puts current_versions
+        end
+      else
+        File.open(versions_file, "w") do |file|
+          file.puts timestamp
+        end
+      end
+    end
+    
+    def build_pages
+      %w(pages stylesheets).each do |template_path|
+        Dir["#{@staticmatic.src_dir}/#{template_path}/**/*"].each do |path|
+          if File.directory? path
+            unless File.exists? build_path_for(path)
+              @staticmatic.logger.info("Creating: #{build_path_for(path)}")
+              FileUtils.mkdir(build_path_for(path))
+            end
+          else
+            format = @staticmatic.determine_format_for(path).to_s
+            base_template_name = base_template_name_for(path)
+
+            @staticmatic.template.template_format = format
+            build_file_path = "#{build_path_for(path)}"
+
+            if !StaticMatic::Config[:use_build_tracking] || should_overwrite?(path, build_file_path)
+              output = (format == "html") ? 
+                @staticmatic.render_with_layout(base_template_name) : 
+                @staticmatic.render(base_template_name)
+                          
+              output_prefix = "#{template_path}/" if template_path != "pages"
+              save_built_file(build_file_path, output)
+            end
+          end
+        end
+      end
+    end
+    
+    def should_overwrite?(template_file, build_file)
+      return true unless File.exists?(build_file)
+      file_changed?(template_file)
+    end
+    
+    def file_changed?(src_file)
+      template_modification_time = File.stat(src_file).mtime.strftime("%Y%m%d%H%M%S")
+      template_modification_time.to_i > @last_build.to_i
+    end
+    
+    # Strip off src file path and extension
+    def base_template_name_for(path)
+      path.gsub("#{@staticmatic.root_dir}/", "").
+           gsub(/^src\//, '').
+           gsub(/^pages\//, '').
+           gsub(/\.[a-z]+$/, '')
+    end
+    
+    # Return an output filename
+    def build_path_for(path)
+      File.join(@staticmatic.build_dir, base_template_name_for(path))
+    end
+    
+    # Save contents to the specified file with the given extension to the build directory
+    def save_built_file(path, contents)
+      @staticmatic.logger.info("Generating #{path}")
+      File.open(path, 'w+') do |f|
+        f << contents
+      end
+    end
+    
+    class << self
+      def build(staticmatic)
+        staticmatic = StaticMatic::Base.new(staticmatic) if staticmatic.is_a? String
+        new(staticmatic)
+      end
+    end
+  end
+end

data/lib/staticmatic/config.rb

@@ -0,0 +1,47 @@
+module StaticMatic
+  class Config
+    class << self
+      def defaults
+        @defaults ||= {
+          :host                   => "0.0.0.0",
+          :port                   => "3000",
+          :sass_options           => {},
+          :haml_options           => {},
+          :use_build_tracking     => true
+        }
+      end
+
+      def setup(settings = {})
+        @configuration = defaults.merge(settings)
+      end
+      
+      def use
+        yield @configuration
+      end
+
+      def key?(key)
+        @configuration.key?(key)
+      end
+
+      def [](key)
+        (@configuration||={})[key]
+      end
+
+      def []=(key,val)
+        @configuration[key] = val
+      end
+
+      def delete(key)
+        @configuration.delete(key)
+      end
+
+      def fetch(key, default)
+        @configuration.fetch(key, default)
+      end
+
+      def to_hash
+        @configuration
+      end
+    end
+  end
+end

data/lib/staticmatic/creator.rb

@@ -0,0 +1,18 @@
+module StaticMatic
+  class Creator
+    class << self
+      def setup(directory)
+        FileUtils.mkdir(directory) unless File.exists?(directory)
+        
+        template_directory = Dir.glob(File.dirname(__FILE__) + "/templates/default/**")
+        
+        FileUtils.cp_r(template_directory, directory)
+        
+        unless File.exists?(directory + "/build")
+          FileUtils.mkdir(directory + "/build")
+          FileUtils.mkdir(directory + "/build/stylesheets")
+        end
+      end
+    end
+  end
+end

data/lib/staticmatic/deprecation.rb

@@ -0,0 +1,26 @@
+module StaticMatic
+  module Deprecation
+    def deprecate(options = {})
+      message = "#{caller_method_name} has been deprecated and will be removed."
+      message << %Q{ Please use "#{options[:alt]}" instead } if options[:alt]
+      
+      logger.warn(message)
+    end
+    
+  private
+    
+    # Thanks to http://snippets.dzone.com/posts/show/2787 for this nugget
+    def caller_method_name
+      parse_caller(caller(2).first).last
+    end
+
+    def parse_caller(at)
+      if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+        file = Regexp.last_match[1]
+    		line = Regexp.last_match[2].to_i
+    		method = Regexp.last_match[3]
+    		[file, line, method]
+    	end
+    end
+  end
+end

data/lib/staticmatic/helpers/asset_tag_helper.rb

@@ -0,0 +1,37 @@
+module StaticMatic
+  module Helpers
+    module AssetTagHelper
+      def stylesheet_link_tag(*sources)
+        options = sources.extract_options!.stringify_keys
+        expand_stylesheet_sources(sources).collect do |source| 
+          stylesheet_tag(source, options) 
+        end.join("\n")
+      end
+  
+      def javascript_include_tag(*sources)
+        options = sources.extract_options!.stringify_keys
+        expand_javascript_sources(sources).collect do |source|  
+          javascript_src_tag(source, options)
+        end.join("\n")
+      end
+      
+      def javascript_src_tag(source, options)
+        content_tag("script", "", { "type" => Mime::JS, "src" => compute_public_path(source, "javascripts", "js") }.merge(options))
+      end
+
+      def stylesheet_tag(source, options)
+        tag("link", { "rel" => "stylesheet", "type" => Mime::CSS, "media" => "screen", "href" => compute_public_path(source, "stylesheets", "css") }.merge(options), false, false)
+      end
+      
+      def compute_public_path(source, dir, ext = nil, include_host = true)
+        path = "#{relative_path_to_root}#{dir}/#{source}"
+        path << ".#{ext}" if ext
+        path
+      end
+  
+      def relative_path_to_root
+        @relative_path_to_root
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/deprecated_helpers.rb

@@ -0,0 +1,48 @@
+module StaticMatic
+  module Helpers
+    module DeprecatedHelpers
+      def stylesheets(*params)
+        deprecate :alt => "stylesheet_link_tag"
+
+        if params.blank?
+          glob = File.join(@staticmatic.src_dir, 'stylesheets', '*.sass')
+          stylesheets = Dir[glob].inject([]) do |sum, stylesheet|
+            sum << File.basename(stylesheet).chomp(File.extname(stylesheet))
+          end
+        
+          stylesheets.concat assets_from_build_directory("stylesheets", "css", stylesheets)
+        
+          params = stylesheets
+        end
+      
+        stylesheet_link_tag(params)
+      end
+    
+      def link(title, href = "", options = {})
+        deprecate :alt => "link_to"
+        link_to(title, href, options)
+      end
+    
+      def img(name, options = {})
+        deprecate :alt => "image_tag"
+        image_tag(name, options)
+      end
+    
+      def javascripts(*files)
+        javascript_include_tag(files)
+      end
+    
+      private 
+      # Return an array of asset files from a given build directory
+      #
+      # Optionally pass in an array to exclude files served dynamically
+      def assets_from_build_directory(dir, ext, exclude = [])
+        glob = File.join(@staticmatic.build_dir, dir, "*.#{ext}")
+        Dir[glob].inject([]) do |sum, file|
+          file = File.basename(file).chomp(File.extname(file))
+          sum << file unless exclude && exclude.include?(file)
+        end
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/page_helper.rb

@@ -0,0 +1,9 @@
+module StaticMatic
+  module Helpers
+    module PageHelper
+      def current_page
+        @current_page
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/url_helper.rb

@@ -0,0 +1,19 @@
+module StaticMatic
+  module Helpers
+    module UrlHelper
+      def link_to(name, options = {}, html_options = nil)
+        options = urlify(name) if options == {}
+        super(name, options, html_options)
+      end
+    
+      def urlify(string)
+        string.tr(" ", "_").
+               sub("&", "and").
+               sub("@", "at").
+               tr("^A-Za-z0-9_", "").
+               sub(/_{2,}/, "_").
+               downcase
+      end
+    end
+  end
+end

data/lib/staticmatic/previewer.rb

@@ -0,0 +1,65 @@
+require 'mongrel'
+
+module StaticMatic
+  class Previewer < Mongrel::HttpHandler
+    @@file_only_methods = %w(GET HEAD)
+ 
+    def initialize(staticmatic)
+      @files = Mongrel::DirHandler.new(staticmatic.build_dir, false)
+      @staticmatic = staticmatic
+    end
+  
+    def process(request, response)
+      @staticmatic.load_helpers
+      path_info = request.params[Mongrel::Const::PATH_INFO]
+      get_or_head = @@file_only_methods.include? request.params[Mongrel::Const::REQUEST_METHOD]
+      
+      file_ext = File.extname(path_info).gsub(/^\./, '') 
+      file_ext = "html" if file_ext.blank?
+      
+      file_name = path_info.chomp(".#{file_ext}")
+      file_name = CGI::unescape(file_name)
+      file_name.gsub!(/^\//, '')
+
+      if file_ext && file_ext.match(/html|css/)
+        response.start(200) do |head, out|
+          head["Content-Type"] = "text/#{file_ext}"
+          output = ""
+          
+          if @staticmatic.can_render? path_info
+            output = (file_ext == "css") ?
+              @staticmatic.render(path_info) :
+              @staticmatic.render_with_layout(file_name)
+          else
+            if @files.can_serve(path_info)
+              @files.process(request,response)
+            else
+              output = "File not Found"
+            end
+          end
+          out.write output
+        end
+      else
+        # try to serve static file from site dir
+        @files.process(request,response) if @files.can_serve(path_info)
+      end
+    end
+    
+    class << self
+      # Starts the StaticMatic preview server
+      def start(staticmatic)
+        staticmatic = StaticMatic::Base.new(staticmatic) if staticmatic.is_a? String
+
+        config = Mongrel::Configurator.new :host => StaticMatic::Config[:host] do
+          puts "Running Preview of #{staticmatic.root_dir} on port #{StaticMatic::Config[:post]}"
+          listener :port => StaticMatic::Config[:port] do
+            uri "/", :handler => Previewer.new(staticmatic)
+          end
+          trap("INT") { stop }
+          run
+        end
+        config.join
+      end
+    end
+  end
+end

data/lib/staticmatic/rescue.rb

@@ -0,0 +1,14 @@
+module StaticMatic
+  module Rescue
+    # Render an error template for the given exception
+    def rescue_from_error(exception)
+      rescue_template = (exception == ActionView::TemplateError) ?
+        "template_error" :
+        "default_error"
+      
+      error_template_path = File.expand_path(File.dirname(__FILE__) + "/templates/rescues/#{rescue_template}.html.erb")
+      @template.instance_variable_set("@exception", exception)
+      @template.render_file(error_template_path, false)
+    end
+  end
+end

data/lib/staticmatic/template_handlers/haml.rb

@@ -0,0 +1,19 @@
+require 'haml'
+require 'haml/engine'
+
+module StaticMatic
+  module TemplateHandlers
+    class Haml < ActionView::TemplateHandler
+      include ActionView::TemplateHandlers::Compilable
+
+      def compile(template, local_assigns = {})
+        options = StaticMatic::Config[:haml_options].dup
+        options[:filename] = template.filename
+
+        ::Haml::Engine.new(template.source, options).send(:precompiled_with_ambles, [])
+      end
+    end
+  end
+end
+
+ActionView::Template.register_template_handler(:haml, StaticMatic::TemplateHandlers::Haml)

data/lib/staticmatic/template_handlers/liquid.rb

@@ -0,0 +1,13 @@
+require 'liquid'
+
+module StaticMatic
+  module TemplateHandlers
+    class Liquid < ActionView::TemplateHandler
+      def render(template, local_assigns = {})
+        ::Liquid::Template.parse(template.source).render(local_assigns)
+      end
+    end
+  end
+end
+
+ActionView::Template.register_template_handler(:liquid, StaticMatic::TemplateHandlers::Liquid)