tdreyno-staticmatic 2.1.0 → 2.1.1

data/bin/staticmatic

@@ -1,17 +1,5 @@
 #!/usr/bin/env ruby
 
 require 'rubygems'
-require 'rubigen'
-
-if %w(-v --version).include? ARGV.first
-  require 'staticmatic/version'
-  puts "#{File.basename($0)} #{Staticmatic::VERSION::STRING}"
-  exit(0)
-end
-
-require 'rubigen/scripts/generate'
-source = RubiGen::PathSource.new(:application, 
-  File.join(File.dirname(__FILE__), "../app_generators"))
-RubiGen::Base.reset_sources
-RubiGen::Base.append_sources source
-RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'staticmatic')
+require File.join(File.dirname(__FILE__), '..', 'lib', 'staticmatic', 'generator')
+StaticMatic::Generator.run_cli(Dir.pwd, 'staticmatic', 1, ["setup"].concat(ARGV))

data/lib/staticmatic/actionpack_support/remove_controller_caching.rb

@@ -0,0 +1,7 @@
+module ActionController
+  class Base
+    def self.perform_caching
+      false
+    end
+  end
+end

data/lib/staticmatic/autoload.rb

@@ -1,18 +1,20 @@
 module StaticMatic
-  autoload :Builder,     'staticmatic/builder'
-  autoload :Config,      'staticmatic/config'
-  autoload :Deprecation, 'staticmatic/deprecation'
-  autoload :Previewer,   'staticmatic/previewer'
-  autoload :Rescue,      'staticmatic/rescue'
+  autoload :Base,        File.join(File.dirname(__FILE__), 'base')
+  autoload :Config,      File.join(File.dirname(__FILE__), 'config')
+  autoload :Generator,   File.join(File.dirname(__FILE__), 'generator')
+  autoload :Deprecation, File.join(File.dirname(__FILE__), 'deprecation')
+  autoload :Previewer,   File.join(File.dirname(__FILE__), 'previewer')
   
   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'
+    autoload :AssetTagHelper, File.join(File.dirname(__FILE__), 'helpers', 'asset_tag_helper')
+    autoload :PageHelper,     File.join(File.dirname(__FILE__), 'helpers', 'page_helper')
+    autoload :UrlHelper,      File.join(File.dirname(__FILE__), 'helpers', 'url_helper')
   end
-end
-
-require 'staticmatic/actionpack_support/mime'
-require 'staticmatic/actionpack_support/remove_partial_benchmark'
-require 'staticmatic/actionpack_support/remove_controller_caching'
+  
+  module TemplateHandlers
+  end
+  
+  module Generator
+    autoload :BuilderGenerator, File.join(File.dirname(__FILE__), 'builder')
+  end
+end

data/lib/staticmatic/base.rb

@@ -1,160 +1,131 @@
 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
-    
+  
+    attr_accessor :logger, :root_dir, :src_dir, :build_dir
+  
     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
+      @root_dir  = root_dir
+      @src_dir   = File.join(@root_dir, "src")
+      @build_dir = File.join(@root_dir, "build")
     
-    def initialize_config
+      # Setup logger
+      @logger = Logger.new(STDERR)
+      @logger.level = Logger::INFO
+    
+      # User 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
+  
+    # 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?(filename)
+      relative_path = full_template_path(filename)
+      view.template_format = determine_format_for(relative_path)
+      view.finder.class.reload!
+      view.finder.file_exists?(strip_extension(relative_path))
+    end
+  
+    def rendered_ext(filename)
+      regex = Regexp.new('\.(' + ActionView::Template.template_handler_extensions.join('|') + ')')
+      filename.gsub(regex, '')
     end
     
-    def initialize_logger
-      @logger = Logger.new($stderr)
-      @logger.level = Logger::INFO
-      @logger
+    # Return the format for a given template path 
+    #
+    # For example: application.css.sass -> :css
+    def determine_format_for(filename)
+      extension = File.extname(filename)
+
+      # For templates that have only handler extensions, default for backwards compatibility
+      extension = ".html" if extension.empty? || extension == ".haml"
+      extension = ".css"  if extension == ".sass"
+
+      extension[1,extension.length-1].to_sym
     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)
+    def calculate_relative_path_to_root(template)
+      return '' if template.match(/^((\.\.?)?\/|\#|.+?\:)/)
+
+      current_page_depth = template.split('/').length - 2;
+      (current_page_depth > 0) ? ([ '..' ] * current_page_depth).join('/') + '/' : ''
     end
+  
+    def render(filename)
+      load_helpers
+      output = do_render(filename)
     
-    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)
+      return output if determine_format_for(filename) == :css
+      layout = view.instance_variable_get("@layout")
+      layout = "site" if layout.nil?
+      return output unless layout
+    
+      view.instance_variable_set("@content_for_layout", output)
+      view.instance_variable_set("@layout", nil) # Clean @layout variable for next request
+      do_render("layouts/#{layout}")
+    rescue Exception => e
+      rescue_from_error(e)
+    end
+  
+    def view
+      @view ||= begin
+        # Initialize View
+        view = ActionView::Base.new([], {}, self)
+        view.template_format = :html
+        view.finder.view_paths = [ @src_dir ]
+        view.instance_variable_set("@staticmatic", self)
+        view
       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 ||= "site"
-      
-      render("layouts/#{layout}")
+  
+    def do_render(filename)
+      filename = full_template_path(filename)
+      view.instance_variable_set("@current_page", filename)
+      view.template_format = determine_format_for(filename)
+      view.render_file(strip_extension(filename), true)
     end
+  
+    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")
     
+      view.instance_variable_set("@exception", exception)
+      view.render_file(error_template_path, false)
+    end
+  
     # Load all helpers from src/helpers/
     def load_helpers
-      Dir["#{@src_dir}/helpers/**/*_helper.rb"].each do |helper|
-        load helper
+      Dir[File.join(@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
+  
+    # Full path to a template, relative to src/
+    def full_template_path(template)
+      template  = template.gsub("#{@src_dir}/", '')
+      directory = template_directory_for(template)
+      template  = File.join(directory, template) unless directory.empty?
+    
+      path     = File.join(File.expand_path(src_dir), template)
+      template = File.join(template, "index") if File.directory? path
     
+      template
+    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
+      template.match(/^(\/)?(layouts|stylesheets|pages)/) ? "" : "pages"
     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
+      template.split('.').first
     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

@@ -1,102 +1,80 @@
+require 'templater'
+
 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"
+  module Generator
+    extend Templater::Manifold
+    desc "Multiple ways to build a staticmatic site"
+
+    class BuilderGenerator < Templater::Generator
+      # Setup StaticMatic site
+      def self.site; @@site ||= ::StaticMatic::Base.new(Dir.pwd); end
+      def site;      self.class.site; end
+
+      # Define source and desintation
+      def self.source_root; site.src_dir; end
+      def destination_root; site.build_dir; end
       
-      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
+      # Override the base template to handle haml/sass/layouts
+      option :format, :default => :html, :desc => "Which format to export as (html, rails, dotnet)"
+      def self.template(name, *args, &block)
+        # template = case format
+        #   when :rails
+        #     RailsTemplate
+        #   when :dotnet
+        #     DotNetTemplate
+        #   else
+        #     HTMLTemplate
+        # end
+
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        source, destination = args
+        destination ||= source
+        templates << Templater::ActionDescription.new(name, options) do |generator|
+          HTMLTemplate.new(generator, name, source, destination, options)
         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))
+      
+      %w(images javascripts stylesheets pages).each do |dir|
+        base_path = File.join(source_root, dir)
+        Dir[File.join(base_path, "**", "*")].each do |path|
+          next if File.directory?(path)
+          relative_path = path.gsub("#{source_root}/", "")
+          
+          if !%w(images javascripts).include?(dir) && site.can_render?(relative_path)
+            destination_path = site.rendered_ext(relative_path)
+          
+            if dir == 'pages'
+              destination_path.gsub!("pages/", "")
+              next if destination_path =~ /^_/
             end
+            
+            template :rendered_file, relative_path,  destination_path
           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
+            file :static_file, relative_path
           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
+    class HTMLTemplate < Templater::Actions::Template
+      def render
+        generator.site.render(source)
       end
     end
     
-    class << self
-      def build(staticmatic)
-        staticmatic = StaticMatic::Base.new(staticmatic) if staticmatic.is_a? String
-        new(staticmatic)
-      end
-    end
+    # class RailsTemplate < Templater::Actions::Template
+    #   def render
+    #     # No render, just copy it
+    #   end
+    # end
+    #
+    # class DotNetTemplate < Templater::Actions::Template
+    #   def render
+    #     # Wrap with MasterPage tags
+    #     @staticmatic.render(file_name) # no layout
+    #   end
+    # end
+    
+    add :build, BuilderGenerator
   end
 end

data/lib/staticmatic/config.rb

@@ -1,47 +1,41 @@
-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
+class StaticMatic::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 setup(settings = {})
+      @configuration = defaults.merge(settings)
+    end
 
-      def key?(key)
-        @configuration.key?(key)
-      end
+    def key?(key)
+      @configuration.key?(key)
+    end
 
-      def [](key)
-        (@configuration||={})[key]
-      end
+    def [](key)
+      (@configuration||={})[key]
+    end
 
-      def []=(key,val)
-        @configuration[key] = val
-      end
+    def []=(key,val)
+      @configuration[key] = val
+    end
 
-      def delete(key)
-        @configuration.delete(key)
-      end
+    def delete(key)
+      @configuration.delete(key)
+    end
 
-      def fetch(key, default)
-        @configuration.fetch(key, default)
-      end
+    def fetch(key, default)
+      @configuration.fetch(key, default)
+    end
 
-      def to_hash
-        @configuration
-      end
+    def to_hash
+      @configuration
     end
   end
 end

data/lib/staticmatic/previewer.rb

@@ -2,37 +2,27 @@ 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)
+      @files       = Mongrel::DirHandler.new(staticmatic.src_dir, false)
       @staticmatic = staticmatic
     end
   
     def process(request, response)
-      path_info = request.params[Mongrel::Const::PATH_INFO].chomp("/")
-      get_or_head = @@file_only_methods.include? request.params[Mongrel::Const::REQUEST_METHOD]
+      path_info   = request.params[Mongrel::Const::PATH_INFO].chomp("/")
+      get_or_head = %w(GET HEAD).include? request.params[Mongrel::Const::REQUEST_METHOD]
       
-      if get_or_head and @files.can_serve(path_info)
-        @files.process(request, response) # try to serve static file from site dir
-      elsif @staticmatic.can_render? path_info
-        response.start(200) do |head, out|
-          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!(/^\//, '')
-        
-          head["Content-Type"] = "text/#{file_ext}"
-          output = ""
+      if StaticMatic::Base.can_render? path_info  
+        file_ext  = File.extname(path_info).gsub(/^\./, '')
+        file_ext  = "html" if file_ext.blank?
+        file_name = CGI::unescape(path_info.chomp(".#{file_ext}")).gsub!(/^\//, '')
         
-          @staticmatic.load_helpers
-          output = (file_ext == "css") ?
-            @staticmatic.render(path_info) :
-            @staticmatic.render_with_layout(file_name)
-          out.write output
-        end
+        response.start(200) do |head, out|
+          output = Template.new(file_name).render
+          head[Mongrel::Const::CONTENT_TYPE] = Mongrel::DirHandler::MIME_TYPES[".#{file_ext}"] || "application/octet-stream"
+          out.write(output || "")
+        end  
+      elsif get_or_head and @files.can_serve(path_info)
+        @files.process(request, response) # try to serve static file from site dir
       end
     end
     
@@ -40,8 +30,7 @@ module StaticMatic
       # 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
+        Mongrel::Configurator.new :host => StaticMatic::Config[:host] do
           puts "Running Preview of #{staticmatic.root_dir} on port #{StaticMatic::Config[:port]}"
           listener :port => StaticMatic::Config[:port] do
             uri "/", :handler => Previewer.new(staticmatic)
@@ -49,8 +38,7 @@ module StaticMatic
           end
           trap("INT") { stop }
           run
-        end
-        config.join
+        end.join
       end
     end
   end

data/lib/staticmatic/template_handlers/haml.rb

@@ -1,18 +1,14 @@
 require 'haml'
 require 'haml/engine'
 
-module StaticMatic
-  module TemplateHandlers
-    class Haml < ActionView::TemplateHandler
-      include ActionView::TemplateHandlers::Compilable
+class StaticMatic::TemplateHandlers::Haml < ActionView::TemplateHandler
+  include ActionView::TemplateHandlers::Compilable
 
-      def compile(template, local_assigns = {})
-        options = StaticMatic::Config[:haml_options].dup
-        options[:filename] = template.filename
+  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
+    ::Haml::Engine.new(template.source, options).send(:precompiled_with_ambles, [])
   end
 end