staticmatic2 2.0.0

data/lib/staticmatic/mixins/build.rb

@@ -0,0 +1,77 @@
+module StaticMatic::BuildMixin
+    
+  def build
+    build_css
+    build_js
+    build_html
+    copy_images
+  end
+    
+  # Build HTML from the source files
+  def build_html
+    src_file_paths('haml').each do |path|
+      file_dir, template = source_template_from_path(path.sub(/^#{@src_dir}/, ''))
+      save_page(File.join(file_dir, template), generate_html_with_layout(template, file_dir))
+    end
+  end
+
+  # Build CSS from the source files
+  def build_css
+    src_file_paths('sass','scss').each do |path|
+      file_dir, template = source_template_from_path(path.sub(/^#{@src_dir}/, ''))
+      
+      if !template.match(/(^|\/)\_/)
+        save_stylesheet(File.join(file_dir, template), generate_css(template, file_dir))
+      end
+    end
+  end
+  
+  def build_js
+    coffee_found = ENV['PATH'].split(':').inject(false) { |found, folder| found |= File.exists?("#{folder}/coffee") }
+    if coffee_found
+      src_file_paths('coffee').each do |path|
+        file_dir, template = source_template_from_path(path.sub(/^#{@src_dir}/, ''))
+        save_javascript(File.join(file_dir, template), generate_js(template, file_dir))
+      end
+    end
+    # copy normal javascript files over
+    src_file_paths('js').each do |path|
+      file_dir, template = source_template_from_path(path.sub(/^#{@src_dir}/, ''))
+      copy_file(path, File.join(@site_dir, file_dir, "#{template}.js"))
+    end
+  end
+  
+  def copy_images
+    src_file_paths(*%w{gif jpg jpef png tiff}).each do |path|
+      file_dir, file_name = File.split(path.sub(/^#{@src_dir}/, ''))
+      copy_file(path, File.join(@site_dir, 'images', file_dir, file_name))
+    end
+  end
+
+  def copy_file(from, to)
+    FileUtils.mkdir_p(File.dirname(to))
+    FileUtils.cp(from, to)
+  end
+
+  def save_page(filename, content)
+    generate_site_file(filename, 'html', content)
+  end
+
+  def save_stylesheet(filename, content)
+    generate_site_file(filename, 'css', content)
+  end
+
+  def save_javascript(filename, content)
+    generate_site_file(filename, 'js', content)
+  end
+
+  def generate_site_file(filename, extension, content)
+    path = File.join(@site_dir,"#{filename}.#{extension}")
+    FileUtils.mkdir_p(File.dirname(path))
+    File.open(path, 'w+') do |f|
+      f << content
+    end
+    
+    puts "created #{path}"
+  end
+end

data/lib/staticmatic/mixins/helpers.rb

@@ -0,0 +1,15 @@
+module StaticMatic::HelpersMixin    
+  # Loads any helpers present in the helpers dir and mixes them into the template helpers
+  def load_helpers
+
+    Dir["#{@src_dir}/_helpers/**/*_helper.rb"].each do |helper|
+      load_helper(helper)
+    end
+  end
+
+  def load_helper(helper)
+    load helper
+    module_name = File.basename(helper, '.rb').gsub(/(^|\_)./) { |c| c.upcase }.gsub(/\_/, '')
+    Haml::Helpers.class_eval("include #{module_name}")
+  end
+end

data/lib/staticmatic/mixins/render.rb

@@ -0,0 +1,153 @@
+module StaticMatic::RenderMixin
+  
+  # clear all scope variables except @staticmatic
+  def clear_template_variables!
+    
+    @scope.instance_variables.each do |var|
+      @scope.instance_variable_set(var, nil) unless var == '@staticmatic' || var == :@staticmatic
+    end
+  end
+  
+  def source_for_layout
+    if layout_exists?(determine_layout)
+      File.read(full_layout_path(determine_layout))
+    else
+      raise StaticMatic::Error.new("", full_layout_path(determine_layout), "Layout not found")
+    end
+  end
+
+  # Generate html from source file:
+  # generate_html("index")
+  def generate_html(source_file, source_dir = '')
+    full_file_path = File.join(@src_dir, source_dir, "#{source_file}.haml")
+
+    begin
+
+      html = generate_html_from_template_source(File.read(full_file_path))
+    rescue StaticMatic::TemplateError => e
+      raise e # re-raise inline errors
+    rescue Exception => e
+      raise StaticMatic::TemplateError.new(full_file_path, e)
+    end
+
+    html
+  end
+
+  def generate_html_with_layout(source, source_dir = '')
+    @current_page = File.join(source_dir, "#{source}.html")
+    @current_file_stack.unshift(File.join(source_dir, "#{source}.haml"))
+    begin 
+      template_content = generate_html(source, source_dir)
+      generate_html_from_template_source(source_for_layout) { template_content }
+    rescue Exception => e
+      render_rescue_from_error(e)
+    ensure
+      clear_template_variables!
+      @current_page = nil
+      @current_file_stack.shift
+    end
+  end
+
+  def generate_partial(name, options = {})
+    partial_dir, partial_name = File.dirname(self.current_file), name  # default relative to current file
+    partial_dir, partial_name = File.split(name) if name.index('/') # contains a path so it's absolute from src/pages dir
+    partial_type = partial_name[/(\.haml|\.html)$/]
+    
+    partial_name = "_#{partial_name}"
+    partial_name += ".haml" unless partial_type
+
+    partial_path = File.join(@src_dir, partial_dir, partial_name)
+    unless File.exists?(partial_path)
+      # couldn't find it in the pages subdirectory tree so try old way (ignoring the path)
+      partial_dir = '_partials'
+      partial_name = "#{File.basename(name)}"
+      partial_name += ".haml" unless partial_type
+      partial_path = File.join(@src_dir, partial_dir, partial_name)
+    end
+  
+    if File.exists?(partial_path)
+      partial_rel_path = "/#{partial_dir}/#{partial_name}".gsub(/\/+/, '/')
+      @current_file_stack.unshift(partial_rel_path)
+      begin
+        if partial_type == '.html'
+          File.read(partial_path)
+        else
+          generate_html_from_template_source(File.read(partial_path), options)
+        end
+      rescue Exception => e
+        raise StaticMatic::TemplateError.new(partial_path, e)
+      ensure
+        @current_file_stack.shift
+      end
+    else
+      raise StaticMatic::Error.new("", name, "Partial not found")
+    end
+  end
+
+  def generate_css(source, source_dir = '')
+    full_file_path = Dir[File.join(@src_dir, source_dir, "#{source}.{sass,scss}")].first
+
+    if full_file_path && File.exist?(full_file_path)
+      begin
+        sass_options = { :load_paths => [ @src_dir ] }.merge(self.configuration.sass_options)
+      
+        if File.extname(full_file_path) == ".scss"
+          sass_options[:syntax] = :scss
+        end
+      
+        stylesheet = Sass::Engine.new(File.read(full_file_path), sass_options)
+        stylesheet.to_css
+      rescue Exception => e
+        render_rescue_from_error(StaticMatic::TemplateError.new(full_file_path, e))
+      end
+    else
+      raise StaticMatic::Error.new("", source, "Stylesheet not found")
+    end
+  end
+
+  def generate_js(source, source_dir = '')
+    full_file_path = File.join(@src_dir, source_dir, "#{source}.coffee")
+
+    coffee_options = "#{self.configuration.coffee_options} -p"
+    javascript = `coffee #{coffee_options} #{full_file_path}`
+  end
+
+  # Generates html from the passed source string
+  #
+  # generate_html_from_template_source("%h1 Welcome to My Site") -> "<h1>Welcome to My Site</h1>"
+  #
+  # Pass a block containing a string to yield within in the passed source:
+  #
+  # generate_html_from_template_source("content:\n= yield") { "blah" } -> "content: blah"
+  #
+  def generate_html_from_template_source(source, options = {})
+    html = Haml::Engine.new(source, self.configuration.haml_options.merge(options))
+    locals = options[:locals] || {}
+    html.render(@scope, locals) { yield }
+  end
+
+  def determine_layout(dir = '')
+    layout_name ||= @default_layout
+  
+    if @scope.instance_variable_get("@layout")
+      layout_name = @scope.instance_variable_get("@layout")
+    elsif dir
+      dirs = dir.split("/")
+      dir_layout_name = dirs[1]
+    
+      if layout_exists?(dir_layout_name)
+        layout_name = dir_layout_name
+      end
+    end
+
+    layout_name 
+  end
+    
+  # Returns a raw template name from a source file path:
+  # source_template_from_path("/path/to/site/src/stylesheets/application.sass")  ->  "application"
+  def source_template_from_path(path)
+    file_dir, file_name = File.split(path)
+    file_name.chomp!(File.extname(file_name))
+    [ file_dir, file_name ]
+  end
+end

data/lib/staticmatic/mixins/rescue.rb

@@ -0,0 +1,12 @@
+module StaticMatic::RescueMixin
+  # Pass back an error template for the given exception
+  def render_rescue_from_error(exception)
+    rescue_template     = (exception.is_a?(StaticMatic::TemplateError)) ? "template" : "default"
+      
+    error_template_path = File.expand_path(File.dirname(__FILE__) + "/../templates/rescues/#{rescue_template}.haml")
+    
+    @scope.instance_variable_set("@exception", exception)
+    
+    generate_html_from_template_source(File.read(error_template_path))
+  end
+end

data/lib/staticmatic/mixins/server.rb

@@ -0,0 +1,7 @@
+module StaticMatic::ServerMixin
+  def preview
+    puts "StaticMatic Preview Server"
+    puts "Ctrl+C to exit"
+    StaticMatic::Server.start(self)
+  end
+end

data/lib/staticmatic/mixins/setup.rb

@@ -0,0 +1,16 @@
+module StaticMatic::SetupMixin
+  
+  def setup
+    Dir.mkdir(@base_dir) unless File.exists?(@base_dir)
+    
+    Dir[File.join(File.dirname(__FILE__), "..", "templates", "project", "*")].each do |template|
+      begin
+        FileUtils.cp_r(template, @base_dir)
+      rescue Errno::EEXIST
+        # ignore - template exists
+      end
+    end
+
+    puts "Done"
+  end
+end

data/lib/staticmatic/server.rb

@@ -0,0 +1,86 @@
+module StaticMatic
+  class Server
+    def initialize(staticmatic, default = nil)
+      @files = default || Rack::File.new(staticmatic.src_dir)
+      @staticmatic = staticmatic
+      
+
+    end
+
+    def call(env)
+      @staticmatic.load_helpers
+      path_info = env["PATH_INFO"]
+
+      file_dir, file_name, file_ext = expand_path(path_info)
+      
+      file_dir = CGI::unescape(file_dir)
+      file_name = CGI::unescape(file_name)
+
+      unless file_ext && ["html", "css", "js"].include?(file_ext) &&
+          @staticmatic.template_exists?(file_name, file_ext, file_dir) &&
+          File.basename(file_name) !~ /^\_/
+        return @files.call(env)
+      end
+
+      res = Rack::Response.new
+      res.header["Content-Type"] = "text/#{file_ext}"
+
+      begin
+        if file_ext == "css"
+          res.write @staticmatic.generate_css(file_name, file_dir)
+        elsif file_ext == "js"
+          res.header["Content-Type"] = "text/javascript"
+          res.write @staticmatic.generate_js(file_name, file_dir)
+        else
+          res.write @staticmatic.generate_html_with_layout(file_name, file_dir)
+        end
+      rescue StaticMatic::Error => e
+        res.write e.message
+      end
+
+      res.finish
+    end
+
+    # Starts the StaticMatic preview server
+    def self.start(staticmatic)
+      [ 'INT', 'TERM' ].each do |signal|
+        Signal.trap(signal) do
+          puts 
+          puts "Exiting"
+          exit!(0)
+        end
+      end
+      port = staticmatic.configuration.preview_server_port || 3000
+
+      host = staticmatic.configuration.preview_server_host || ""
+
+      app = Rack::Builder.new do
+        use Rack::ShowExceptions
+        run StaticMatic::Server.new(staticmatic)
+      end 
+      
+      Rack::Handler::WEBrick.run(app, :Port => port, :Host => host)
+    end
+
+    private
+
+    def expand_path(path_info)
+      dirname, basename = File.split(path_info)
+
+      extname = File.extname(path_info).sub(/^\./, '')
+      filename = basename.chomp(".#{extname}")
+
+      if extname.empty?
+        dir = File.join(dirname, filename)
+        is_dir = path_info[-1, 1] == '/'
+        if is_dir
+          dirname = dir
+          filename = 'index'
+        end
+        extname = 'html'
+      end
+
+      [ dirname, filename, extname ]
+    end
+  end
+end

data/lib/staticmatic/template_error.rb

@@ -0,0 +1,44 @@
+class StaticMatic::TemplateError < StandardError
+  SOURCE_CODE_RADIUS = 3
+  
+  attr_reader :original_exception, :backtrace
+
+  def initialize(template, original_exception)
+    @template, @original_exception = template, original_exception
+    @backtrace = original_exception.backtrace
+    
+    if template
+      @source = File.read(template)
+    else 
+      @source = ""
+    end
+  end
+  
+  # TODO: Replace 'haml|sass' with any registered engines
+  def line_number
+    @line_number ||= $2 if backtrace.find { |line| line =~ /\((haml|sass|scss)\)\:(\d+)/ }
+  end
+  
+  def filename
+    @template
+  end
+  
+  def source_extract(indentation = 0)
+    return "" unless num = line_number
+    num = num.to_i
+
+    source_code = @source.split("\n")
+
+    start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
+    end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
+
+    indent = ' ' * indentation
+    line_counter = start_on_line
+    return unless source_code = source_code[start_on_line..end_on_line]
+
+    source_code.collect do |line|
+      line_counter += 1
+      "#{indent}#{line_counter}: #{line}\n"
+    end.to_s
+  end
+end

data/lib/staticmatic/templates/rescues/default.haml

@@ -0,0 +1,7 @@
+%h1= @exception.class.name
+
+%p= @exception.message
+
+%h2 Stack Trace
+
+= @exception.backtrace.join("<br/>")

data/lib/staticmatic/templates/rescues/template.haml

@@ -0,0 +1,18 @@
+%html
+  %head
+    %style{:type => "text/css"}
+      body { font-family: helvetica, verdana, arial; font-size: 10pt;}
+  %body
+    %h1
+      = @exception.class.name
+      in
+      = @exception.filename
+
+    %p= @exception.original_exception.message
+  
+    = @exception.source_extract.gsub(/\n/, "<br/>")
+
+
+    %h2 Backtrace
+
+    = @exception.backtrace.join("<br/>")