staticmatic3 2.1.9

data/lib/staticmatic/helpers.rb

@@ -0,0 +1,12 @@
+["assets", "form", "current_path", "render", "tag", "url"].each do |helper|
+  require File.join(File.dirname(__FILE__), "helpers", "#{helper}_helper")
+end
+
+module StaticMatic::Helpers
+  include TagHelper
+  include UrlHelper  
+  include AssetsHelper
+  include FormHelper
+  include RenderHelper
+  include CurrentPathHelper  
+end

data/lib/staticmatic/helpers/assets_helper.rb

@@ -0,0 +1,116 @@
+module StaticMatic
+  module Helpers
+    module AssetsHelper
+      self.extend self
+      
+      # Generates links to all stylesheets in the source directory
+      # = stylesheets
+      # or specific stylesheets in a specific order
+      # = stylesheets :reset, :application
+      # Can also pass options hash in at the end so you can specify :media => :print
+      def stylesheets(*params)
+        options = (params.last.is_a? Hash) ? params.pop : {}
+        
+        options[:media] = 'all' unless options.has_key?(:media)
+        options[:rel] = 'stylesheet'; options[:type] = 'text/css'
+
+        src_files = @staticmatic.src_file_paths('sass','scss','css')
+        output = ""
+
+        if params.length == 0
+          # no specified files; include them all!
+          src_files.each {|path| output << format_output(:link,path,options) }
+        else
+          # specific files requested and in a specific order
+          params.each do |file|
+
+            if file.to_s.match %r{^https?://}
+              output << format_output(:link,file,options)
+            else
+              idx = src_files.index do |src|
+                %w{sass scss css}.map {|t| src.match /#{file}\.#{t}$/ }.any?
+              end
+              output << format_output(:link,src_files[idx],options) unless idx.nil?
+            end
+          end
+        end
+        output
+      end
+      
+      # Generate javascript source tags for the specified files
+      #
+      # javascripts('test')   ->   <script language="javascript" src="path/to/test.js"></script>
+      #    
+      def javascripts(*files)
+        options = (files.last.is_a? Hash) ? files.pop : {}
+        
+        options[:language] = 'javascript'
+        options[:type] = 'text/javascript'
+        
+        src_files = @staticmatic.src_file_paths('js','coffee')
+        output = ""
+
+        files.each do |path|
+          if path.to_s.match %r{^https?://}
+            output << format_output(:script,path,options)
+          else
+            idx = src_files.index do |src|
+              %w{coffee js}.map {|t| src.match /#{path.to_s}\.#{t}$/ }.any?
+            end
+            output << format_output(:script,src_files[idx],options) unless idx.nil?
+          end
+        end
+        output
+      end
+
+      # Generates an image tag always relative to the current page unless absolute path or http url specified.
+      # 
+      # img('test_image.gif')   ->   <img src="/images/test_image.gif" alt="Test image"/>
+      # img('contact/test_image.gif')   ->   <img src="/images/contact/test_image.gif" alt="Test image"/>
+      # img('http://localhost/test_image.gif')   ->   <img src="http://localhost/test_image.gif" alt="Test image"/>
+      def img(name, options = {})
+        options[:src] = name.match(%r{^((\.\.?)?/|https?://)}) ? name : "#{current_page_relative_path}images/#{name}"
+        options[:alt] ||= name.split('/').last.split('.').first.capitalize.gsub(/_|-/, ' ')
+        tag :img, options
+      end
+      
+      def format_output(tag_type,path,options)
+        external_url = !!path.match(%r{^https?://})
+
+        if external_url
+          src = path
+        else
+          filename_without_extension = File.basename(path).chomp(File.extname(path))
+      
+          path = path.gsub(/^#{@staticmatic.src_dir}/, "").
+                     gsub(/^#{@staticmatic.site_dir}/, "").
+                     gsub(/#{filename_without_extension}\.(sass|scss|css|js|coffee)/, "").
+                     gsub(/^\//, "")
+          paths = [current_page_relative_path, path, "#{filename_without_extension}"].compact
+          src = File.join(*paths)
+        end
+        
+        if tag_type == :link
+          src += '.css' if !external_url
+          options[:href] = qstring(src, options[:qstring]); options.delete :qstring
+          tag(tag_type,options)
+        elsif tag_type == :script
+          src += '.js' if !external_url
+          options[:src] = qstring(src, options[:qstring]); options.delete :qstring
+          tag(tag_type,options) { '' }
+        end
+        
+      end
+      
+      # Prepares a query string based on the given qstr.
+      # If qstr is true, it generates a query string based on the current time.
+      # If qstr is a string, it uses it as the query string itself.
+      # 
+      def qstring(src,qstr)
+        src += '?_=' + Time.now.to_i.to_s if qstr == true
+        src += '?_=' + qstr if qstr.is_a? String
+        src
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/current_path_helper.rb

@@ -0,0 +1,22 @@
+module StaticMatic
+  module Helpers
+    module CurrentPathHelper
+      self.extend self
+      
+      def current_page
+        @staticmatic.current_file
+      end
+
+      private
+
+      def current_page_relative_path(current_path = nil)
+        if current_path.nil? || current_path.match(/^((\.\.?)?\/|\#|.+?\:)/) == nil
+          current_page_depth = current_page.split('/').length - 3;
+          (current_page_depth > 0) ? ([ '..' ] * current_page_depth).join('/') + '/' : nil
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/form_helper.rb

@@ -0,0 +1,23 @@
+
+module StaticMatic
+  module Helpers
+    module FormHelper
+      self.extend self
+
+      # Generates a form text field
+      #
+      def text_field(name, value, options = {})
+        options.merge!(:type => "text", :name => name, :value => value)
+        tag(:input, options)
+      end
+        
+        
+      # Generate a form textarea
+      #
+      def text_area(name, value, options = {})
+        options.merge!(:name => name)
+        tag(:textarea, options) { value }
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/render_helper.rb

@@ -0,0 +1,14 @@
+
+module StaticMatic
+  module Helpers
+    module RenderHelper
+      self.extend self
+      
+      # Include a partial template
+      def partial(name, options = {})
+        name = @staticmatic.ensure_extension(name)
+        @staticmatic.generate_partial(name, options)
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/tag_helper.rb

@@ -0,0 +1,35 @@
+module StaticMatic
+  module Helpers
+    module TagHelper
+      self.extend self
+      
+      # Generates HTML tags:
+      #
+      # tag(:br)   ->   <br/>
+      # tag(:a, :href => 'test.html') { "Test" }    ->    <a href="test.html">Test</a>
+      #
+      def tag(name, options = {}, &block)
+        options[:id] ||= options[:name] if options[:name]
+        output = "<#{name}"
+        options.keys.sort { |a, b| a.to_s <=> b.to_s }.each do |key|
+          output << " #{key}=\"#{options[key]}\"" if options[key]
+        end
+        
+        if block_given?
+          output << ">"
+          output << yield
+          output << "</#{name}>"
+        else
+          format = @staticmatic.configuration.engine_options['haml'][:format]
+          
+          if format.nil? || format == :xhtml
+            output << "/>"
+          else
+            output << ">"
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/url_helper.rb

@@ -0,0 +1,59 @@
+module StaticMatic
+  module Helpers
+    module UrlHelper
+      self.extend self
+      
+      # Generate an HTML link
+      #
+      # If only the title is passed, it will automatically
+      # create a link from this value:
+      #
+      # link('Test')  ->  <a href="test.html">Test</a>
+      #
+      def link(title, href = "", options = {})
+        if href.is_a?(Hash)
+          options = href
+          href = ""
+        end
+
+        if href.nil? || href.strip.length < 1
+          path_prefix = ''
+          if title.match(/^(\.\.?)?\//)
+            # starts with relative path so strip it off and prepend it to the urlified title
+            path_prefix_match = title.match(/^[^\s]*\//)
+            path_prefix = path_prefix_match[0] if path_prefix_match
+            title = title[path_prefix.length, title.length]
+          end
+          href = path_prefix + urlify(title) + ".html"
+        end
+
+        options[:href] = "#{current_page_relative_path(href)}#{href}"
+        
+        local_page = (options[:href].match(/^(\#|.+?\:)/) == nil)
+        unless @staticmatic.configuration.use_extensions_for_page_links || !local_page
+          options[:href].chomp!(".html")
+          options[:href].chomp!("index") if options[:href][-5, 5] == 'index'
+        end
+
+        tag(:a, options) { title }
+      end
+      alias link_to link
+
+      # Generates a URL friendly string from the value passed:
+      #
+      # "We love Haml"  ->  "we_love_haml"
+      # "Elf & Ham"     ->  "elf_and_ham"
+      # "Stephen's gem" ->  "stephens_gem"
+      #
+      def urlify(string)
+        string.tr(" ", "_").
+               sub("&", "and").
+               sub("@", "at").
+               tr("^A-Za-z0-9_", "").
+               sub(/_{2,}/, "_").
+               downcase
+      end
+    end
+  end
+
+end

data/lib/staticmatic/mixins/build.rb

@@ -0,0 +1,41 @@
+module StaticMatic::BuildMixin
+
+  def build
+    src_file_paths('*').each do |src_path|
+      ext = File.extname(src_path).sub(/^\./, '')
+
+      if Tilt.mappings[ext].length > 0 and not File.directory? src_path
+        generate_site_file(src_path)
+      else
+        copy_file_from_src_to_site(src_path)
+      end
+    end
+  end
+
+  private
+
+  def copy_file_from_src_to_site(src_path)
+    site_path = src_path.gsub /^#{@src_dir}/, @site_dir
+
+    FileUtils.mkdir_p(File.dirname site_path)
+    FileUtils.cp_r src_path, site_path
+  end
+
+  def generate_site_file(src_path)
+    dir, name, ext = expand_path(src_path.gsub /^#{@src_dir}/, @site_dir)
+    target_ext = configuration.reverse_ext_mappings[ext]
+    site_path = File.join(dir, "#{name}.#{target_ext}")
+
+    puts "  Rendered #{src_path} => #{site_path}"
+
+    FileUtils.mkdir_p(File.dirname site_path)
+    File.open(site_path, 'w+') do |f|
+      if target_ext == 'html'
+        f << render_template_with_layout(src_path)
+      else
+        f << render_template(src_path)
+      end
+    end
+  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,110 @@
+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
+  
+  # Generate html from source file:
+  # render_template("index.haml")
+  def render_template(file_path)
+    @current_file_stack.push(file_path)
+    begin
+      tilt_template(file_path)
+    rescue StaticMatic::TemplateError => e
+      raise e # re-raise inline errors
+    rescue Exception => e
+      raise StaticMatic::TemplateError.new(file_path, e)
+    ensure
+      @current_file_stack.pop
+    end
+  end
+
+  def render_template_with_layout(file_path)
+    @current_file_stack.push(file_path)
+    begin 
+      rendered_file_content = render_template(file_path)
+      tilt_template_with_layout(fetch_layout_path) { rendered_file_content }
+    rescue Exception => e
+      render_rescue_from_error(e)
+    ensure
+      @current_file_stack.pop
+    end
+  end
+
+  def generate_partial(name, options = {})
+    partial_dir, partial_name, partial_ext = expand_path name
+    partial_name = "_#{partial_name}"
+
+    context = File.join File.dirname(self.current_file), partial_dir
+    partial_path = determine_template_path(partial_name, partial_ext, context)
+
+    unless partial_path && File.exists?(partial_path)
+      # partial not found in the current file's directory, so try the _partials folder
+      context = File.join @src_dir, '_partials', partial_dir
+      partial_name.sub! /^_/, ''
+      partial_path = determine_template_path(partial_name, partial_ext, context)
+    end
+  
+    if partial_path && File.exists?(partial_path)
+      return render_template partial_path
+    else
+      raise StaticMatic::Error.new("", name, "Partial not found")
+    end
+  end
+
+  def fetch_layout_path(dir = nil)
+    layout_path = File.join(@src_dir, "_layouts")
+    declared_layout_name = @scope.instance_variable_get("@layout")
+
+    if declared_layout_name
+      path = determine_template_path declared_layout_name, '', layout_path
+      unless path
+        error_path = File.join(layout_path, declared_layout_name)
+        raise StaticMatic::Error.new("", error_path, "Layout not found")
+      end
+    end
+
+    if dir
+      dir_layout_name = dir.split("/")[1]
+      path ||= determine_template_path dir_layout_name, '', layout_path
+    end
+    path ||= determine_template_path @default_layout_name, '', layout_path
+
+    unless path
+      error_path = File.join(layout_path, @default_layout_name)
+      raise StaticMatic::Error.new("", error_path, "No default layout could be found")
+    end
+
+    return path
+  end
+
+  private
+
+  # TODO: more code reuse. needs some ruby &block and yield sorcery.
+  def tilt_template(file_path)
+    options = get_engine_options(file_path)
+    Tilt.new(file_path, options).render(@scope)
+  end
+
+  def tilt_template_with_layout(file_path)
+    options = get_engine_options(file_path)
+    Tilt.new(file_path, options).render(@scope) { yield }
+  end
+
+  def get_engine_options(file_path)
+    ext = File.extname(file_path).sub(/^\./, '')
+    options = configuration.engine_options[ext] || {}
+    preview_options = configuration.preview_engine_options[ext] || {}
+
+    if @mode == :preview
+      options.merge preview_options
+    else
+      options
+    end
+  end
+
+end