simple-templater 0.0.1.4 → 0.0.1.5

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

@@ -1,140 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,225 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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