mack-haml 0.8.1 → 0.8.2

data/lib/gems/haml-2.0.4/lib/sass/error.rb

@@ -0,0 +1,35 @@
+module Sass
+  # Sass::SyntaxError encapsulates information about the exception,
+  # such as the line of the Sass template it was raised on
+  # and the Sass file that was being parsed (if applicable).
+  # It also provides a handy way to rescue only exceptions raised
+  # because of a faulty template.
+  class SyntaxError < StandardError
+    # The line of the Sass template on which the exception was thrown.
+    attr_accessor :sass_line
+
+    # The name of the file that was being parsed when the exception was raised.
+    # This will be nil unless Sass is being used as an ActionView plugin.
+    attr_reader :sass_filename
+
+    # Creates a new SyntaxError.
+    # +lineno+ should be the line of the Sass template on which the error occurred.
+    def initialize(msg, lineno = nil)
+      @message = msg
+      @sass_line = lineno
+    end
+
+    # Adds a properly formatted entry to the exception's backtrace.
+    # +filename+ should be the file in which the error occurred,
+    # if applicable (defaults to "(sass)").
+    def add_backtrace_entry(filename) # :nodoc:
+      @sass_filename ||= filename
+      self.backtrace ||= []
+      self.backtrace.unshift "#{@sass_filename || '(sass)'}:#{@sass_line}"
+    end
+
+    def to_s # :nodoc:
+      @message
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+require 'sass/engine'
+
+module Sass
+  # This module contains methods to aid in using Sass
+  # as a stylesheet-rendering plugin for various systems.
+  # Currently Rails/ActionController and Merb are supported out of the box.
+  module Plugin
+    class << self
+      @@options = {
+        :template_location  => './public/stylesheets/sass',
+        :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 updates
+      # (in this Ruby instance).
+      def checked_for_updates
+        @@checked_for_updates
+      end
+
+      # Gets various options for Sass. See README.rdoc for details.
+      #--
+      # TODO: *DOCUMENT OPTIONS*
+      #++
+      def options
+        @@options
+      end
+
+      # Sets various options for Sass.
+      def options=(value)
+        @@options.merge!(value)
+      end
+
+      # Get the options ready to be passed to the Sass::Engine
+      def engine_options(additional_options = {})
+        opts = options.dup.merge(additional_options)
+        opts[:load_paths] = load_paths(opts)
+        opts
+      end
+
+      # Checks each stylesheet in <tt>options[:css_location]</tt>
+      # to see if it needs updating,
+      # and updates it using the corresponding template
+      # from <tt>options[:templates]</tt>
+      # if it does.
+      def update_stylesheets
+        return if options[:never_update]
+
+        @@checked_for_updates = true
+        Dir.glob(File.join(options[:template_location], "**", "*.sass")).entries.each do |file|
+
+          # Get the relative path to the file with no extension
+          name = file.sub(options[:template_location] + "/", "")[0...-5]
+
+          if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name))
+            css = css_filename(name)
+            File.delete(css) if File.exists?(css)
+
+            filename = template_filename(name)
+            engine = Engine.new(File.read(filename), engine_options(:filename => filename))
+            result = begin
+                       engine.render
+                     rescue Exception => e
+                       exception_string(e)
+                     end
+
+            # Create any directories that might be necessary
+            dirs = [options[:css_location]]
+            name.split("/")[0...-1].each { |dir| dirs << "#{dirs[-1]}/#{dir}" }
+            dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
+
+            # Finally, write the file
+            File.open(css, 'w') do |file|
+              file.print(result)
+            end
+          end
+        end
+      end
+
+      private
+
+      def load_paths(opts = options)
+        (opts[:load_paths] || []) + [options[:template_location]]
+      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
+                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
+              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)
+        "#{options[:template_location]}/#{name}.sass"
+      end
+
+      def css_filename(name)
+        "#{options[:css_location]}/#{name}.css"
+      end
+
+      def forbid_update?(name)
+        name.sub(/^.*\//, '')[0] == ?_
+      end
+
+      def stylesheet_needs_update?(name)
+        if !File.exists?(css_filename(name))
+          return true
+        else
+          css_mtime = File.mtime(css_filename(name))
+          File.mtime(template_filename(name)) > css_mtime ||
+            dependencies(template_filename(name)).any?(&dependency_updated?(css_mtime))
+        end
+      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::Engine.find_file_to_import(inc.strip, load_paths)
+          end
+        end.flatten.grep(/\.sass$/)
+      end
+    end
+  end
+end
+
+require 'sass/plugin/rails' if defined?(ActionController)
+require 'sass/plugin/merb'  if defined?(Merb::Plugins)

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

@@ -0,0 +1,56 @@
+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',
+                              :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 # :nodoc:
+      def call_with_sass(env)
+        if !Sass::Plugin.checked_for_updates ||
+            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+          Sass::Plugin.update_stylesheets
+        end
+
+        call_without_sass(env)
+      end
+      alias_method :call_without_sass, :call
+      alias_method :call, :call_with_sass
+    end
+
+  else
+
+    class MerbHandler # :nodoc:
+      def process_with_sass(request, response)
+        if !Sass::Plugin.checked_for_updates ||
+            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+          Sass::Plugin.update_stylesheets
+        end
+
+        process_without_sass(request, response)
+      end
+      alias_method :process_without_sass, :process
+      alias_method :process, :process_with_sass
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+unless defined?(Sass::RAILS_LOADED)
+  Sass::RAILS_LOADED = true
+
+  Sass::Plugin.options.merge!(:template_location  => RAILS_ROOT + '/public/stylesheets/sass',
+                              :css_location       => RAILS_ROOT + '/public/stylesheets',
+                              :always_check       => RAILS_ENV != "production",
+                              :full_exception     => RAILS_ENV != "production")
+
+  # :stopdoc:
+  module ActionController
+    class Base
+      alias_method :sass_old_process, :process
+      def process(*args)
+        if !Sass::Plugin.checked_for_updates ||
+            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+          Sass::Plugin.update_stylesheets
+        end
+
+        sass_old_process(*args)
+      end
+    end
+  end
+  # :startdoc:
+end

data/lib/gems/haml-2.0.4/lib/sass/tree/attr_node.rb

@@ -0,0 +1,53 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  class AttrNode < ValueNode
+    attr_accessor :name
+
+    def initialize(name, value, style)
+      @name = name
+      super(value, style)
+    end
+
+    def to_s(tabs, parent_name = nil)
+      if value[-1] == ?;
+        raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump} (This isn't CSS!).", @line)
+      end
+      real_name = name
+      real_name = "#{parent_name}-#{real_name}" if parent_name
+
+      if value.empty? && children.empty?
+        raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump}.", @line)
+      end
+
+      join_string = case @style
+                    when :compact; ' '
+                    when :compressed; ''
+                    else "\n"
+                    end
+      spaces = '  ' * (tabs - 1)
+      to_return = ''
+      if !value.empty?
+        to_return << "#{spaces}#{real_name}:#{@style == :compressed ? '' : ' '}#{value};#{join_string}"
+      end
+
+      children.each do |kid|
+        to_return << "#{kid.to_s(tabs, real_name)}" << join_string
+      end
+
+      (@style == :compressed && parent_name) ? to_return : to_return[0...-1]
+    end
+
+    private
+
+    def declaration
+      ":#{name} #{value}"
+    end
+
+    def invalid_child?(child)
+      if !child.is_a?(AttrNode) && !child.is_a?(CommentNode)
+        "Illegal nesting: Only attributes may be nested beneath attributes."
+      end
+    end
+  end
+end

data/lib/gems/haml-2.0.4/lib/sass/tree/comment_node.rb

@@ -0,0 +1,20 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  class CommentNode < ValueNode
+    def initialize(value, style)
+      super(value[2..-1].strip, style)
+    end
+
+    def to_s(tabs = 0, parent_name = nil)
+      return if @style == :compressed
+
+      spaces = '  ' * (tabs - 1)
+      join_string = @style == :compact ? ' ' : "\n#{spaces} * "
+      str = "#{spaces}/* #{value}"
+      str << join_string unless children.empty?
+      str << "#{children.join join_string} */"
+      str
+    end
+  end
+end

data/lib/gems/haml-2.0.4/lib/sass/tree/directive_node.rb

@@ -0,0 +1,46 @@
+require 'sass/tree/node'
+require 'sass/tree/value_node'
+
+module Sass::Tree
+  class DirectiveNode < ValueNode
+    def to_s(tabs)
+      if children.empty?
+        value + ";"
+      else
+        result = if @style == :compressed
+                   "#{value}{"
+                 else
+                   "#{'  ' * (tabs - 1)}#{value} {" + (@style == :compact ? ' ' : "\n")
+                 end
+        was_attr = false
+        first = true
+        children.each do |child|
+          if @style == :compact
+            if child.is_a?(AttrNode)
+              result << "#{child.to_s(first || was_attr ? 1 : tabs + 1)} "
+            else
+              if was_attr
+                result[-1] = "\n"
+              end
+              rendered = child.to_s(tabs + 1)
+              rendered.lstrip! if first
+              result << rendered
+            end
+            was_attr = child.is_a?(AttrNode)
+            first = false
+          elsif @style == :compressed
+            result << (was_attr ? ";#{child.to_s(1)}" : child.to_s(1))
+            was_attr = child.is_a?(AttrNode)
+          else
+            result << child.to_s(tabs + 1) + "\n"
+          end
+        end
+        result.rstrip + if @style == :compressed
+                          "}"
+                        else
+                          (@style == :expanded ? "\n" : " ") + "}\n"
+                        end
+      end
+    end
+  end
+end

data/lib/gems/haml-2.0.4/lib/sass/tree/node.rb

@@ -0,0 +1,42 @@
+module Sass
+  module Tree
+    class Node
+      attr_accessor :children
+      attr_accessor :line
+      attr_accessor :filename
+
+      def initialize(style)
+        @style = style
+        @children = []
+      end
+
+      def <<(child)
+        if msg = invalid_child?(child)
+          raise Sass::SyntaxError.new(msg, child.line)
+        end
+        @children << child
+      end
+
+      def to_s
+        result = String.new
+        children.each do |child|
+          if child.is_a? AttrNode
+            raise SyntaxError.new('Attributes aren\'t allowed at the root of a document.', child.line)
+          else
+            result << "#{child.to_s(1)}" + (@style == :compressed ? '' : "\n")
+          end
+        end
+        @style == :compressed ? result+"\n" : result[0...-1]
+      end
+
+      private
+
+      # This method should be overridden by subclasses to return an error message
+      # if the given child node is invalid,
+      # and false or nil otherwise.
+      def invalid_child?(child)
+        false
+      end
+    end
+  end
+end