drnic-haml 2.3.0

data/lib/sass/environment.rb

@@ -0,0 +1,79 @@
+module Sass
+  # The lexical environment for SassScript.
+  # This keeps track of variable and mixin definitions.
+  #
+  # A new environment is created for each level of Sass nesting.
+  # This allows variables to be lexically scoped.
+  # The new environment refers to the environment in the upper scope,
+  # so it has access to variables defined in enclosing scopes,
+  # but new variables are defined locally.
+  #
+  # Environment also keeps track of the {Engine} options
+  # so that they can be made available to {Sass::Script::Functions}.
+  class Environment
+    # The enclosing environment,
+    # or nil if this is the global environment.
+    #
+    # @return [Environment]
+    attr_reader :parent
+    attr_writer :options
+
+    # @param parent [Environment] See \{#parent}
+    def initialize(parent = nil)
+      @vars = {}
+      @mixins = {}
+      @parent = parent
+
+      set_var("important", Script::String.new("!important")) unless @parent
+    end
+
+    # The options hash.
+    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    #
+    # @return [Hash<Symbol, Object>]
+    def options
+      @options || (parent && parent.options) || {}
+    end
+
+    class << self
+      private
+
+      # Note: when updating this,
+      # update haml/yard/inherited_hash.rb as well.
+      def inherited_hash(name)
+        class_eval <<RUBY, __FILE__, __LINE__ + 1
+          def #{name}(name)
+            @#{name}s[name] || @parent && @parent.#{name}(name)
+          end
+
+          def set_#{name}(name, value)
+            @#{name}s[name] = value unless try_set_#{name}(name, value)
+          end
+
+          def try_set_#{name}(name, value)
+            if @#{name}s.include?(name)
+              @#{name}s[name] = value
+              true
+            elsif @parent
+              @parent.try_set_#{name}(name, value)
+            else
+              false
+            end
+          end
+          protected :try_set_#{name}
+
+          def set_local_#{name}(name, value)
+            @#{name}s[name] = value
+          end
+RUBY
+      end
+    end
+
+    # variable
+    # Script::Literal
+    inherited_hash :var
+    # mixin
+    # Engine::Mixin
+    inherited_hash :mixin
+  end
+end

data/lib/sass/error.rb

@@ -0,0 +1,162 @@
+module Sass
+  # An exception class that keeps track of
+  # the line of the Sass template it was raised on
+  # and the Sass file that was being parsed (if applicable).
+  #
+  # All Sass errors are raised as {Sass::SyntaxError}s.
+  #
+  # When dealing with SyntaxErrors,
+  # it's important to provide filename and line number information.
+  # This will be used in various error reports to users, including backtraces;
+  # see \{#sass\_backtrace} for details.
+  #
+  # Some of this information is usually provided as part of the constructor.
+  # New backtrace entries can be added with \{#add\_backtrace},
+  # which is called when an exception is raised between files (e.g. with `@import`).
+  #
+  # Often, a chunk of code will all have similar backtrace information -
+  # the same filename or even line.
+  # It may also be useful to have a default line number set.
+  # In those situations, the default values can be used
+  # by omitting the information on the original exception,
+  # and then calling \{#modify\_backtrace} in a wrapper `rescue`.
+  # When doing this, be sure that all exceptions ultimately end up
+  # with the information filled in.
+  class SyntaxError < StandardError
+    # The backtrace of the error within Sass files.
+    # This is an array of hashes containing information for a single entry.
+    # The hashes have the following keys:
+    #
+    # `:filename`
+    # : The name of the file in which the exception was raised,
+    #   or `nil` if no filename is available.
+    #
+    # `:line`
+    # : The line of the file on which the error occurred. Never nil.
+    #
+    # This information is also included in standard backtrace format
+    # in the output of \{#backtrace}.
+    #
+    # @return [Aray<Hash<Symbol, Object>>]
+    attr_accessor :sass_backtrace
+
+    # The text of the template where this error was raised.
+    #
+    # @return [String]
+    attr_accessor :sass_template
+
+    # @param msg [String] The error message
+    # @param attrs [Hash<Symbol, Object>] The information in the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def initialize(msg, attrs = {})
+      @message = msg
+      @sass_backtrace = []
+      add_backtrace(attrs)
+    end
+
+    # The name of the file in which the exception was raised.
+    # This could be `nil` if no filename is available.
+    #
+    # @return [String]
+    def sass_filename
+      sass_backtrace.first[:filename]
+    end
+
+    # The line of the Sass template on which the error occurred.
+    #
+    # @return [Fixnum]
+    def sass_line
+      sass_backtrace.first[:line]
+    end
+
+    # Adds an entry to the exception's Sass backtrace.
+    #
+    # @param attrs [Hash<Symbol, Object>] The information in the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def add_backtrace(attrs)
+      sass_backtrace << attrs.reject {|k, v| v.nil?}
+    end
+
+    # Modify the top Sass backtrace entry (that is, the last one)
+    # to have the given attributes.
+    # If that entry already has one of the given attributes set,
+    # that takes precendence.
+    #
+    # @param attrs [Hash<Symbol, Object>] The information to add to the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def modify_backtrace(attrs)
+      sass_backtrace[-1] = attrs.reject {|k, v| v.nil?}.merge(sass_backtrace.last)
+    end
+
+    # @return [String] The error message
+    def to_s
+      @message
+    end
+
+    # Returns the standard exception backtrace,
+    # including the Sass backtrace.
+    #
+    # @return [Array<String>]
+    def backtrace
+      return nil if super.nil?
+      sass_backtrace.map {|h| "#{h[:filename] || "(sass)"}:#{h[:line]}"} + super
+    end
+
+    # Returns a string representation of the Sass backtrace.
+    #
+    # @param default_filename [String] The filename to use for unknown files
+    # @see #sass_backtrace
+    # @return [String]
+    def sass_backtrace_str(default_filename = "an unknown file")
+      "Syntax error: #{message}" +
+        Haml::Util.enum_with_index(sass_backtrace).map do |entry, i|
+        "\n        #{i == 0 ? "on" : "from"} line #{entry[:line]}" +
+          " of #{entry[:filename] || default_filename}"
+      end.join
+    end
+
+    class << self
+      # Returns an error report for an exception in CSS format.
+      #
+      # @param e [Exception]
+      # @param full_exception [Boolean] The value of
+      #   \{file:SASS\_REFERENCE.md#full_exception-option `options[:full_exception]`}
+      def exception_to_css(e, options)
+        return "/* Internal stylesheet error */" unless options[:full_exception]
+
+        header = header_string(e, options)
+
+        <<END
+/*
+#{header}
+
+Backtrace:\n#{e.backtrace.join("\n")}
+*/
+body:before {
+  white-space: pre;
+  font-family: monospace;
+  content: "#{header.gsub('"', '\"').gsub("\n", '\\A ')}"; }
+END
+      end
+
+      private
+
+      def header_string(e, options)
+        return "#{e.class}: #{e.message}" unless e.is_a? Sass::SyntaxError
+
+        line_offset = options[:line] || 1
+        line_num = e.sass_line + 1 - line_offset
+        min = [line_num - 6, 0].max
+        section = e.sass_template.rstrip.split("\n")[min ... line_num + 5]
+        return e.sass_backtrace_str if section.nil? || section.empty?
+
+        e.sass_backtrace_str + "\n\n" + Haml::Util.enum_with_index(section).
+          map {|line, i| "#{line_offset + min + i}: #{line}"}.join("\n")
+      end
+    end
+  end
+
+  # The class for Sass errors that are raised due to invalid unit conversions
+  # in SassScript.
+  class UnitConversionError < SyntaxError; end
+end

data/lib/sass/files.rb

@@ -0,0 +1,133 @@
+require 'digest/sha1'
+require 'pathname'
+
+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 [Hash<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.
+    #   The caller has responsibility for setting backtrace information, if necessary
+    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))
+
+      root = engine.to_tree
+      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}.")
+    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/lib/sass/plugin.rb

@@ -0,0 +1,170 @@
+require 'sass/engine'
+
+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.
+  # Currently Rails and Merb are supported out of the box.
+  module Plugin
+    include Haml::Util
+    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 [Hash<Symbol, Object>]
+    attr_reader :options
+
+    # Sets the options hash.
+    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    #
+    # @param value [Hash<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 [Hash<Symbol, Object>] An options hash with which to merge \{#options}
+    # @return [Hash<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
+
+    # 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
+                 Sass::SyntaxError.exception_to_css(e, options)
+               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 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)