simple-templater 0.0.1.3 → 0.0.1.4

data/gems/gems/haml-2.2.16/lib/sass/files.rb

@@ -0,0 +1,140 @@
+require 'digest/sha1'
+require 'pathname'
+require 'fileutils'
+
+module Sass
+  # This module contains various bits of functionality
+  # related to finding and caching Sass files.
+  module Files
+    extend self
+
+    # Returns the {Sass::Tree} for the given file,
+    # reading it from the Sass cache if possible.
+    #
+    # @param filename [String] The path to the Sass file
+    # @param options [{Symbol => Object}] The options hash.
+    #   Only the {file:SASS_REFERENCE.md#cache-option `:cache_location`} option is used
+    # @raise [Sass::SyntaxError] if there's an error in the document
+    def tree_for(filename, options)
+      options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
+      text = File.read(filename)
+
+      if options[:cache]
+        compiled_filename = sassc_filename(filename, options)
+        sha = Digest::SHA1.hexdigest(text)
+
+        if root = try_to_read_sassc(filename, compiled_filename, sha)
+          root.options = options.merge(:filename => filename)
+          return root
+        end
+      end
+
+      engine = Sass::Engine.new(text, options.merge(:filename => filename))
+
+      begin
+        root = engine.to_tree
+      rescue Sass::SyntaxError => err
+        err.add_backtrace_entry(filename)
+        raise err
+      end
+
+      try_to_write_sassc(root, compiled_filename, sha, options) if options[:cache]
+
+      root
+    end
+
+    # Find the full filename of a Sass or CSS file to import.
+    # This follows Sass's import rules:
+    # if the filename given ends in `".sass"` or `".css"`,
+    # it will try to find that type of file;
+    # otherwise, it will try to find the corresponding Sass file
+    # and fall back on CSS if it's not available.
+    #
+    # Any Sass filename returned will correspond to
+    # an actual Sass file on the filesystem.
+    # CSS filenames, however, may not;
+    # they're expected to be put through directly to the stylesheet
+    # as CSS `@import` statements.
+    #
+    # @param filename [String] The filename to search for
+    # @param load_paths [Array<String>] The set of filesystem paths
+    #   to search for Sass files.
+    # @return [String] The filename of the imported file.
+    #   This is an absolute path if the file is a `".sass"` file.
+    # @raise [Sass::SyntaxError] if `filename` ends in ``".sass"``
+    #   and no corresponding Sass file could be found.
+    def find_file_to_import(filename, load_paths)
+      was_sass = false
+      original_filename = filename
+
+      if filename[-5..-1] == ".sass"
+        filename = filename[0...-5]
+        was_sass = true
+      elsif filename[-4..-1] == ".css"
+        return filename
+      end
+
+      new_filename = find_full_path("#{filename}.sass", load_paths)
+
+      return new_filename if new_filename
+      return filename + '.css' unless was_sass
+      raise SyntaxError.new("File to import not found or unreadable: #{original_filename}.", @line)
+    end
+
+    private
+
+    def sassc_filename(filename, options)
+      File.join(options[:cache_location],
+        Digest::SHA1.hexdigest(File.dirname(File.expand_path(filename))),
+        File.basename(filename) + 'c')
+    end
+
+    def try_to_read_sassc(filename, compiled_filename, sha)
+      return unless File.readable?(compiled_filename)
+
+      File.open(compiled_filename, "rb") do |f|
+        return unless f.readline("\n").strip == Sass::VERSION
+        return unless f.readline("\n").strip == sha
+        return Marshal.load(f.read)
+      end
+    rescue TypeError, ArgumentError => e
+      warn "Warning. Error encountered while reading cache #{compiled_filename}: #{e}"
+    end
+
+    def try_to_write_sassc(root, compiled_filename, sha, options)
+      return unless File.writable?(File.dirname(options[:cache_location]))
+      return if File.exists?(options[:cache_location]) && !File.writable?(options[:cache_location])
+      return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
+      return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
+      FileUtils.mkdir_p(File.dirname(compiled_filename))
+      File.open(compiled_filename, "wb") do |f|
+        f.write(Sass::VERSION)
+        f.write("\n")
+        f.write(sha)
+        f.write("\n")
+        f.write(Marshal.dump(root))
+      end
+    end
+
+    def find_full_path(filename, load_paths)
+      partial_name = File.join(File.dirname(filename), "_#{File.basename(filename)}")
+
+      if Pathname.new(filename).absolute?
+        [partial_name, filename].each do |name|
+          return name if File.readable?(name)
+        end
+        return nil
+      end
+
+      load_paths.each do |path|
+        [partial_name, filename].each do |name|
+          full_path = File.join(path, name)
+          if File.readable?(full_path)
+            return full_path
+          end
+        end
+      end
+      nil
+    end
+  end
+end

data/gems/gems/haml-2.2.16/lib/sass/plugin/merb.rb

@@ -0,0 +1,49 @@
+unless defined?(Sass::MERB_LOADED)
+  Sass::MERB_LOADED = true
+
+  version = Merb::VERSION.split('.').map { |n| n.to_i }
+  if version[0] <= 0 && version[1] < 5
+    root = MERB_ROOT
+    env  = MERB_ENV
+  else
+    root = Merb.root.to_s
+    env  = Merb.environment
+  end
+
+  Sass::Plugin.options.merge!(:template_location => root + '/public/stylesheets/sass',
+                              :css_location      => root + '/public/stylesheets',
+                              :cache_location    => root + '/tmp/sass-cache',
+                              :always_check      => env != "production",
+                              :full_exception    => env != "production")
+  config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
+
+  if defined? config.symbolize_keys!
+    config.symbolize_keys!
+  end
+
+  Sass::Plugin.options.merge!(config)
+
+  if version[0] > 0 || version[1] >= 9
+
+    class Merb::Rack::Application
+      def call_with_sass(env)
+        Sass::Plugin.check_for_updates
+        call_without_sass(env)
+      end
+      alias_method :call_without_sass, :call
+      alias_method :call, :call_with_sass
+    end
+
+  else
+
+    class MerbHandler
+      def process_with_sass(request, response)
+        Sass::Plugin.check_for_updates
+        process_without_sass(request, response)
+      end
+      alias_method :process_without_sass, :process
+      alias_method :process, :process_with_sass
+    end
+
+  end
+end

data/gems/gems/haml-2.2.16/lib/sass/plugin/rack.rb

@@ -0,0 +1,65 @@
+require 'sass/plugin'
+
+module Sass
+  module Plugin
+    # Rack middleware for compiling Sass code.
+    #
+    # ## Activate
+    #
+    #     require 'sass/plugin/rack'
+    #     use Sass::Plugin::Rack
+    #
+    # ## Customize
+    #
+    #     Sass::Plugin.options.merge(
+    #       :cache_location => './tmp/sass-cache',
+    #       :never_update => environment != :production,
+    #       :full_exception => environment != :production)
+    #
+    # {file:SASS_REFERENCE.md#options See the Reference for more options}.
+    #
+    # ## Use
+    #
+    # Put your Sass files in `public/stylesheets/sass`.
+    # Your CSS will be generated in `public/stylesheets`,
+    # and regenerated every request if necessary.
+    # The locations and frequency {file:SASS_REFERENCE.md#options can be customized}.
+    # That's all there is to it!
+    class Rack
+      # Initialize the middleware.
+      #
+      # @param app [#call] The Rack application
+      def initialize(app)
+        @app = app
+        self.class.disable_native_plugin!
+      end
+
+      # Process a request, checking the Sass stylesheets for changes
+      # and updating them if necessary.
+      #
+      # @param env The Rack request environment
+      # @return [(#to_i, {String => String}, Object)] The Rack response
+      def call(env)
+        Sass::Plugin.check_for_updates
+        @app.call(env)
+      end
+
+      # Disable the native Rails or Merb plugins, if they're enabled.
+      # This is automatically done once the Rack plugin is activated.
+      # This is done so that the stylesheets aren't checked twice for each request.
+      def self.disable_native_plugin!
+        if defined?(Merb::Rack::Application) &&
+            Haml::Util.has?(:instance_method, Merb::Rack::Application, :call_without_sass)
+          Merb::Rack::Application.instance_eval {alias_method :call, :call_without_sass}
+        end
+
+        if defined?(ActionDispatch::Callbacks.to_prepare)
+          ActionDispatch::Callbacks.skip_callback(:prepare, :__sass_process)
+        elsif defined?(ActionController::Base) &&
+            Haml::Util.has?(:instance_method, ActionController::Base, :sass_old_process)
+          ActionController::Base.instance_eval {alias_method :process, :sass_old_process}
+        end
+      end
+    end
+  end
+end

data/gems/gems/haml-2.2.16/lib/sass/plugin/rails.rb

@@ -0,0 +1,24 @@
+unless defined?(Sass::RAILS_LOADED)
+  Sass::RAILS_LOADED = true
+
+  Sass::Plugin.options.merge!(:template_location => Haml::Util.rails_root + '/public/stylesheets/sass',
+                              :css_location      => Haml::Util.rails_root + '/public/stylesheets',
+                              :cache_location    => Haml::Util.rails_root + '/tmp/sass-cache',
+                              :always_check      => RAILS_ENV != "production",
+                              :full_exception    => RAILS_ENV != "production")
+
+  if defined?(ActionDispatch::Callbacks.to_prepare)
+    # Rails >= 3.0.0
+    ActionDispatch::Callbacks.to_prepare(:sass_process) {Sass::Plugin.check_for_updates}
+  else
+    module ActionController
+      class Base
+        alias_method :sass_old_process, :process
+        def process(*args)
+          Sass::Plugin.check_for_updates
+          sass_old_process(*args)
+        end
+      end
+    end
+  end
+end

data/gems/gems/haml-2.2.16/lib/sass/plugin.rb

@@ -0,0 +1,225 @@
+require 'sass'
+
+module Sass
+  # This module handles the compilation of Sass files.
+  # It provides global options and checks whether CSS files
+  # need to be updated.
+  #
+  # This module is used as the primary interface with Sass
+  # when it's used as a plugin for various frameworks.
+  # All Rack-enabled frameworks are supported out of the box.
+  # The plugin is {file:SASS_REFERENCE.md#rails_merb_plugin automatically activated for Rails and Merb}.
+  # Other frameworks must enable it explicitly; see {Sass::Plugin::Rack}.
+  module Plugin
+    extend self
+
+    @options = {
+      :css_location       => './public/stylesheets',
+      :always_update      => false,
+      :always_check       => true,
+      :full_exception     => true
+    }
+    @checked_for_updates = false
+
+    # Whether or not Sass has **ever** checked if the stylesheets need to be updated
+    # (in this Ruby instance).
+    #
+    # @return [Boolean]
+    attr_reader :checked_for_updates
+
+    # An options hash.
+    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    #
+    # @return [{Symbol => Object}]
+    attr_reader :options
+
+    # Sets the options hash.
+    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    #
+    # @param value [{Symbol => Object}] The options hash
+    def options=(value)
+      @options.merge!(value)
+    end
+
+    # Non-destructively modifies \{#options} so that default values are properly set.
+    #
+    # @param additional_options [{Symbol => Object}] An options hash with which to merge \{#options}
+    # @return [{Symbol => Object}] The modified options hash
+    def engine_options(additional_options = {})
+      opts = options.dup.merge(additional_options)
+      opts[:load_paths] = load_paths(opts)
+      opts
+    end
+
+    # Same as \{#update\_stylesheets}, but respects \{#checked\_for\_updates}
+    # and the {file:SASS_REFERENCE.md#always_update-option `:always_update`}
+    # and {file:SASS_REFERENCE.md#always_check-option `:always_check`} options.
+    #
+    # @see #update_stylesheets
+    def check_for_updates
+      return unless !Sass::Plugin.checked_for_updates ||
+          Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+      update_stylesheets
+    end
+
+    # Updates out-of-date stylesheets.
+    #
+    # Checks each Sass file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}
+    # to see if it's been modified more recently than the corresponding CSS file
+    # in {file:SASS_REFERENCE.md#css_location-option} `:css_location`}.
+    # If it has, it updates the CSS file.
+    def update_stylesheets
+      return if options[:never_update]
+
+      @checked_for_updates = true
+      template_locations.zip(css_locations).each do |template_location, css_location|
+
+        Dir.glob(File.join(template_location, "**", "*.sass")).each do |file|
+          # Get the relative path to the file with no extension
+          name = file.sub(template_location + "/", "")[0...-5]
+
+          if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name, template_location, css_location))
+            update_stylesheet(name, template_location, css_location)
+          end
+        end
+      end
+    end
+
+    private
+
+    def update_stylesheet(name, template_location, css_location)
+      css = css_filename(name, css_location)
+      File.delete(css) if File.exists?(css)
+
+      filename = template_filename(name, template_location)
+      result = begin
+                 Sass::Files.tree_for(filename, engine_options(:css_filename => css, :filename => filename)).render
+               rescue Exception => e
+                 exception_string(e)
+               end
+
+      # Create any directories that might be necessary
+      mkpath(css_location, name)
+
+      # Finally, write the file
+      File.open(css, 'w') do |file|
+        file.print(result)
+      end
+    end
+    
+    # Create any successive directories required to be able to write a file to: File.join(base,name)
+    def mkpath(base, name)
+      dirs = [base]
+      name.split(File::SEPARATOR)[0...-1].each { |dir| dirs << File.join(dirs[-1],dir) }
+      dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
+    end
+
+    def load_paths(opts = options)
+      (opts[:load_paths] || []) + template_locations
+    end
+    
+    def template_locations
+      location = (options[:template_location] || File.join(options[:css_location],'sass'))
+      if location.is_a?(String)
+        [location]
+      else
+        location.to_a.map { |l| l.first }
+      end
+    end
+    
+    def css_locations
+      if options[:template_location] && !options[:template_location].is_a?(String)
+        options[:template_location].to_a.map { |l| l.last }
+      else
+        [options[:css_location]]
+      end
+    end
+
+    def exception_string(e)
+      if options[:full_exception]
+        e_string = "#{e.class}: #{e.message}"
+
+        if e.is_a? Sass::SyntaxError
+          e_string << "\non line #{e.sass_line}"
+
+          if e.sass_filename
+            e_string << " of #{e.sass_filename}"
+
+            if File.exists?(e.sass_filename)
+              e_string << "\n\n"
+
+              min = [e.sass_line - 5, 0].max
+              begin
+                File.read(e.sass_filename).rstrip.split("\n")[
+                  min .. e.sass_line + 5
+                ].each_with_index do |line, i|
+                  e_string << "#{min + i + 1}: #{line}\n"
+                end
+              rescue
+                e_string << "Couldn't read sass file: #{e.sass_filename}"
+              end
+            end
+          end
+        end
+        <<END
+/*
+#{e_string}
+
+Backtrace:\n#{e.backtrace.join("\n")}
+*/
+body:before {
+  white-space: pre;
+  font-family: monospace;
+  content: "#{e_string.gsub('"', '\"').gsub("\n", '\\A ')}"; }
+END
+        # Fix an emacs syntax-highlighting hiccup: '
+      else
+        "/* Internal stylesheet error */"
+      end
+    end
+
+    def template_filename(name, path)
+      "#{path}/#{name}.sass"
+    end
+
+    def css_filename(name, path)
+      "#{path}/#{name}.css"
+    end
+
+    def forbid_update?(name)
+      name.sub(/^.*\//, '')[0] == ?_
+    end
+
+    def stylesheet_needs_update?(name, template_path, css_path)
+      css_file = css_filename(name, css_path)
+      template_file = template_filename(name, template_path)
+      exact_stylesheet_needs_update?(css_file, template_file)
+    end
+
+    def exact_stylesheet_needs_update?(css_file, template_file)
+      return true unless File.exists?(css_file)
+
+      css_mtime = File.mtime(css_file)
+      File.mtime(template_file) > css_mtime ||
+        dependencies(template_file).any?(&dependency_updated?(css_mtime))
+    end
+
+    def dependency_updated?(css_mtime)
+      lambda do |dep|
+        File.mtime(dep) > css_mtime ||
+          dependencies(dep).any?(&dependency_updated?(css_mtime))
+      end
+    end
+
+    def dependencies(filename)
+      File.readlines(filename).grep(/^@import /).map do |line|
+        line[8..-1].split(',').map do |inc|
+          Sass::Files.find_file_to_import(inc.strip, [File.dirname(filename)] + load_paths)
+        end
+      end.flatten.grep(/\.sass$/)
+    end
+  end
+end
+
+require 'sass/plugin/rails' if defined?(ActionController)
+require 'sass/plugin/merb'  if defined?(Merb::Plugins)

data/gems/gems/haml-2.2.16/lib/sass/repl.rb

@@ -0,0 +1,58 @@
+require 'readline'
+
+module Sass
+  # Runs a SassScript read-eval-print loop.
+  # It presents a prompt on the terminal,
+  # reads in SassScript expressions,
+  # evaluates them,
+  # and prints the result.
+  class Repl
+    # @param options [{Symbol => Object}] An options hash.
+    def initialize(options = {})
+      @options = options
+    end
+
+    # Starts the read-eval-print loop.
+    def run
+      environment = Environment.new
+      environment.set_var('important', Script::String.new('!important'))
+      @line = 0
+      loop do
+        @line += 1
+        unless text = Readline.readline('>> ')
+          puts
+          return
+        end
+
+        Readline::HISTORY << text
+        parse_input(environment, text)
+      end
+    end
+
+    private
+
+    def parse_input(environment, text)
+      case text
+      when Script::MATCH
+        name = $1
+        guarded = $2 == '||='
+        val = Script::Parser.parse($3, @line, text.size - $3.size)
+
+        unless guarded && environment.var(name)
+          environment.set_var(name, val.perform(environment))
+        end
+
+        p environment.var(name)
+      else
+        p Script::Parser.parse(text, @line, 0).perform(environment)
+      end
+    rescue Sass::SyntaxError => e
+      puts "SyntaxError: #{e.message}"
+      if @options[:trace]
+        e.backtrace.each do |e|
+          puts "\tfrom #{e}"
+        end
+      end
+    end
+  end
+end

data/gems/gems/haml-2.2.16/lib/sass/script/bool.rb

@@ -0,0 +1,17 @@
+require 'sass/script/literal'
+
+module Sass::Script
+  # A SassScript object representing a boolean (true or false) value.
+  class Bool < Literal
+    # The Ruby value of the boolean.
+    #
+    # @return [Boolean]
+    attr_reader :value
+    alias_method :to_bool, :value
+
+    # @return [String] "true" or "false"
+    def to_s
+      @value.to_s
+    end
+  end
+end