haml 3.0.25 → 3.1.0.alpha.2

data/extra/sass-mode.el

@@ -1,207 +0,0 @@
-;;; sass-mode.el --- Major mode for editing Sass files
-
-;; Copyright (c) 2007, 2008 Nathan Weizenbaum
-
-;; Author: Nathan Weizenbaum
-;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 3.0.19
-;; Created: 2007-03-15
-;; By: Nathan Weizenbaum
-;; Keywords: markup, language, css
-;; Package-Requires: ((haml-mode "3.0.14"))
-
-;;; Commentary:
-
-;; Because Sass's indentation schema is similar
-;; to that of YAML and Python, many indentation-related
-;; functions are similar to those in yaml-mode and python-mode.
-
-;; To install, save this on your load path and add the following to
-;; your .emacs file:
-;;
-;; (require 'sass-mode)
-
-;;; Code:
-
-(require 'haml-mode)
-
-;; User definable variables
-
-(defgroup sass nil
-  "Support for the Sass template language."
-  :group 'languages
-  :prefix "sass-")
-
-(defcustom sass-mode-hook nil
-  "Hook run when entering Sass mode."
-  :type 'hook
-  :group 'sass)
-
-(defcustom sass-indent-offset 2
-  "Amount of offset per level of indentation."
-  :type 'integer
-  :group 'sass)
-
-(defvar sass-non-block-openers
-  '("^.*,$" ;; Continued selectors
-    "^ *@\\(extend\\|debug\\|warn\\|include\\|import\\)" ;; Single-line mixins
-    "^ *[$!]" ;; Variables
-    )
-  "A list of regexps that match lines of Sass that couldn't have
-text nested beneath them.")
-
-;; Font lock
-
-(defconst sass-selector-font-lock-keywords
-  '(;; Attribute selectors (e.g. p[foo=bar])
-    ("\\[\\([^]=]+\\)" (1 font-lock-variable-name-face)
-     ("[~|$^*]?=\\([^]=]+\\)" nil nil (1 font-lock-string-face)))
-    ("&"       0 font-lock-constant-face)
-    ("\\.\\w+" 0 font-lock-type-face)
-    ("#\\w+"   0 font-lock-keyword-face)
-    ;; Pseudo-selectors, optionally with arguments (e.g. :first, :nth-child(12))
-    ("\\(::?\\w+\\)" (1 font-lock-function-name-face)
-     ("(\\([^)]+\\))" nil nil (1 font-lock-string-face)))))
-
-(defconst sass-script-font-lock-keywords
-  `(("\"\\([^\"\\\\]\\|\\\\.\\)*\"" 0 font-lock-string-face)
-    ("!\\(\\w\\|_\\)+" 0 font-lock-variable-name-face)
-    ("#[0-9a-fA-F]\\{0,6\\}" 0 font-lock-preprocessor-face)
-    (,(regexp-opt
-       '("true" "false" "black" "silver" "gray" "white" "maroon" "red"
-         "purple" "fuchsia" "green" "lime" "olive" "yellow" "navy"
-         "blue" "teal" "aqua"))
-     0 font-lock-constant-face)
-    (,(regexp-opt '("and" "or" "not")) 0 font-lock-keyword-face)))
-
-(defconst sass-syntax-table
-  (let ((st (make-syntax-table)))
-    (modify-syntax-entry ?- "w" st)
-    (modify-syntax-entry ?_ "w" st)
-    st))
-
-(defconst sass-script-syntax-table
-  (let ((st (make-syntax-table sass-syntax-table)))
-    (modify-syntax-entry ?- "." st)
-    st))
-
-(defconst sass-font-lock-keywords
-  '((sass-highlight-line 1 nil nil t)))
-
-(defconst sass-line-keywords
-  '(("@\\(\\w+\\)"    0 font-lock-keyword-face sass-highlight-directive)
-    ("/[/*].*"  0 font-lock-comment-face)
-    ("[=+]\\w+" 0 font-lock-function-name-face sass-highlight-script-after-match)
-    ("!\\w+"    0 font-lock-variable-name-face sass-highlight-script-after-match)
-    (":\\w+"    0 font-lock-variable-name-face)
-    ("\\w+\s*:" 0 font-lock-variable-name-face)
-    ("\\(\\w+\\)\s*="  1 font-lock-variable-name-face sass-highlight-script-after-match)
-    ("\\(:\\w+\\)\s*=" 1 font-lock-variable-name-face sass-highlight-script-after-match)
-    (".*"      sass-highlight-selector))
-  "A list of full-line Sass syntax to highlight, used by `sass-highlight-line'.
-
-Each item is either of the form (REGEXP SUBEXP FACE), (REGEXP FN),
-or (REGEXP SUBEXP FACE FN).  Each REGEXP is run successively on the
-beginning of non-whitespace on the current line until one matches.
-If it has SUBEXP and FACE, then SUBEXP is highlighted using FACE.
-If it has FN, FN is run.")
-
-(defun sass-highlight-line (limit)
-  "Highlight a single line using some Sass single-line syntax.
-This syntax is taken from `sass-line-keywords'.
-LIMIT is the limit of the search."
-  (save-match-data
-    (when (re-search-forward "^ *\\(.+\\)$" limit t)
-      (goto-char (match-beginning 1))
-      (dolist (keyword sass-line-keywords)
-        (destructuring-bind (keyword subexp-or-fn &optional face fn) keyword
-          (when (looking-at keyword)
-            (if (integerp subexp-or-fn)
-                (put-text-property (match-beginning subexp-or-fn)
-                                   (match-end subexp-or-fn)
-                                   'face face)
-              (setq fn subexp-or-fn))
-            (when fn (funcall fn))
-            (end-of-line)
-            (return t)))))))
-
-(defun sass-highlight-selector ()
-  "Highlight a CSS selector starting at `point' and ending at `end-of-line'."
-  (let ((font-lock-keywords sass-selector-font-lock-keywords)
-        font-lock-multiline)
-    (font-lock-fontify-region
-     (point) (progn (end-of-line) (point))))
-  t)
-
-(defun sass-highlight-script (beg end)
-  "Highlight a section of SassScript between BEG and END."
-  (save-match-data
-    (with-syntax-table sass-script-syntax-table
-      (let ((font-lock-keywords sass-script-font-lock-keywords)
-            font-lock-syntax-table
-            font-lock-extend-region-functions)
-        (font-lock-fontify-region beg end)))))
-
-(defun sass-highlight-script-after-match ()
-  "Highlight a section of SassScript after the last match."
-  (end-of-line)
-  (sass-highlight-script (match-end 0) (point)))
-
-(defun sass-highlight-directive ()
-  "Highlight a Sass directive."
-  (goto-char (match-end 0))
-  (block nil
-    (case (intern (match-string 1))
-      (for
-       (unless (looking-at " +!\\w+") (return))
-       (put-text-property (match-beginning 0) (match-end 0)
-                          'face font-lock-variable-name-face)
-       (goto-char (match-end 0))
-       (unless (looking-at " +from") (return))
-       (put-text-property (match-beginning 0) (match-end 0)
-                          'face font-lock-keyword-face)
-       (goto-char (match-end 0))
-       (when (looking-at " +\\(.+?\\) +\\(to\\|through\\)")
-         (sass-highlight-script (match-beginning 1) (match-end 1))
-         (put-text-property (match-beginning 2) (match-end 2)
-                            'face font-lock-keyword-face))
-       (sass-highlight-script-after-match))
-
-      (else
-       (unless (looking-at " +if") (return))
-       (put-text-property (match-beginning 0) (match-end 0)
-                          'face font-lock-keyword-face)
-       (sass-highlight-script-after-match))
-
-      ((if while debug) (sass-highlight-script-after-match)))))
-
-;; Constants
-
-;; Mode setup
-
-;;;###autoload
-(define-derived-mode sass-mode haml-mode "Sass"
-  "Major mode for editing Sass files."
-  (set-syntax-table sass-syntax-table)
-  (setq font-lock-extend-region-functions
-        '(font-lock-extend-region-wholelines font-lock-extend-region-multiline))
-  (setq font-lock-multiline nil)
-  (setq comment-start "/*")
-  (set (make-local-variable 'haml-indent-function) 'sass-indent-p)
-  (set (make-local-variable 'haml-indent-offset) sass-indent-offset)
-  (setq font-lock-defaults '(sass-font-lock-keywords t t)))
-
-;; Indentation
-
-(defun sass-indent-p ()
-  "Return non-nil if the current line can have lines nested beneath it."
-  (loop for opener in sass-non-block-openers
-        if (looking-at opener) return nil
-        finally return t))
-
-;;;###autoload
-(add-to-list 'auto-mode-alist '("\\.sass$" . sass-mode))
-
-;; Setup/Activation
-(provide 'sass-mode)
-;;; sass-mode.el ends here

data/lib/haml/util/subset_map.rb

@@ -1,101 +0,0 @@
-require 'set'
-
-module Haml
-  module Util
-    # A map from sets to values.
-    # A value is \{#\[]= set} by providing a set (the "set-set") and a value,
-    # which is then recorded as corresponding to that set.
-    # Values are \{#\[] accessed} by providing a set (the "get-set")
-    # and returning all values that correspond to set-sets
-    # that are subsets of the get-set.
-    #
-    # SubsetMap preserves the order of values as they're inserted.
-    #
-    # @example
-    # ssm = SubsetMap.new
-    # ssm[Set[1, 2]] = "Foo"
-    # ssm[Set[2, 3]] = "Bar"
-    # ssm[Set[1, 2, 3]] = "Baz"
-    #
-    # ssm[Set[1, 2, 3]] #=> ["Foo", "Bar", "Baz"]
-    class SubsetMap
-      # Creates a new, empty SubsetMap.
-      def initialize
-        @hash = {}
-        @vals = []
-      end
-
-      # Whether or not this SubsetMap has any key-value pairs.
-      #
-      # @return [Boolean]
-      def empty?
-        @hash.empty?
-      end
-
-      # Associates a value with a set.
-      # When `set` or any of its supersets is accessed,
-      # `value` will be among the values returned.
-      #
-      # Note that if the same `set` is passed to this method multiple times,
-      # all given `value`s will be associated with that `set`.
-      #
-      # This runs in `O(n)` time, where `n` is the size of `set`.
-      #
-      # @param set [#to_set] The set to use as the map key. May not be empty.
-      # @param value [Object] The value to associate with `set`.
-      # @raise [ArgumentError] If `set` is empty.
-      def []=(set, value)
-        raise ArgumentError.new("SubsetMap keys may not be empty.") if set.empty?
-
-        index = @vals.size
-        @vals << value
-        set.each do |k|
-          @hash[k] ||= []
-          @hash[k] << [set, set.to_set, index]
-        end
-      end
-
-      # Returns all values associated with subsets of `set`.
-      #
-      # In the worst case, this runs in `O(m*max(n, log m))` time,
-      # where `n` is the size of `set`
-      # and `m` is the number of assocations in the map.
-      # However, unless many keys in the map overlap with `set`,
-      # `m` will typically be much smaller.
-      #
-      # @param set [Set] The set to use as the map key.
-      # @return [Array<(Object, #to_set)>] An array of pairs,
-      #   where the first value is the value associated with a subset of `set`,
-      #   and the second value is that subset of `set`
-      #   (or whatever `#to_set` object was used to set the value)
-      #   This array is in insertion order.
-      # @see #[]
-      def get(set)
-        res = set.map do |k|
-          next unless subsets = @hash[k]
-          subsets.map do |subenum, subset, index|
-            next unless subset.subset?(set)
-            [index, subenum]
-          end
-        end
-        res = Haml::Util.flatten(res, 1)
-        res.compact!
-        res.uniq!
-        res.sort!
-        res.map! {|i, s| [@vals[i], s]}
-        return res
-      end
-
-      # Same as \{#get}, but doesn't return the subsets of the argument
-      # for which values were found.
-      #
-      # @param set [Set] The set to use as the map key.
-      # @return [Array] The array of all values
-      #   associated with subsets of `set`, in insertion order.
-      # @see #get
-      def [](set)
-        get(set).map {|v, _| v}
-      end
-    end
-  end
-end

data/lib/sass.rb

@@ -1,29 +0,0 @@
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
-require 'haml/version'
-
-# The module that contains everything Sass-related:
-#
-# * {Sass::Engine} is the class used to render Sass/SCSS within Ruby code.
-# * {Sass::Plugin} is interfaces with web frameworks (Rails and Merb in particular).
-# * {Sass::SyntaxError} is raised when Sass encounters an error.
-# * {Sass::CSS} handles conversion of CSS to Sass.
-#
-# Also see the {file:SASS_REFERENCE.md full Sass reference}.
-module Sass
-  extend Haml::Version
-
-  # A string representing the version of Sass.
-  # A more fine-grained representation is available from {Haml::Version#version Sass.version}.
-  # @api public
-  VERSION = version[:string] unless defined?(Sass::VERSION)
-end
-
-require 'haml/util'
-
-dir = Haml::Util.scope("vendor/fssm/lib")
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
-require 'sass/engine'
-require 'sass/plugin' if defined?(Merb::Plugins)

data/lib/sass/callbacks.rb

@@ -1,52 +0,0 @@
-module Sass
-  # A lightweight infrastructure for defining and running callbacks.
-  # Callbacks are defined using \{#define\_callback\} at the class level,
-  # and called using `run_#{name}` at the instance level.
-  #
-  # Clients can add callbacks by calling the generated `on_#{name}` method,
-  # and passing in a block that's run when the callback is activated.
-  #
-  # @example Define a callback
-  # class Munger
-  #   extend Sass::Callbacks
-  #   define_callback :string_munged
-  #
-  #   def munge(str)
-  #     res = str.gsub(/[a-z]/, '\1\1')
-  #     run_string_munged str, res
-  #     res
-  #   end
-  # end
-  #
-  # @example Use a callback
-  # m = Munger.new
-  # m.on_string_munged {|str, res| puts "#{str} was munged into #{res}!"}
-  # m.munge "bar" #=> bar was munged into bbaarr!
-  module Callbacks
-    protected
-
-    # Define a callback with the given name.
-    # This will define an `on_#{name}` method
-    # that registers a block,
-    # and a `run_#{name}` method that runs that block
-    # (optionall with some arguments).
-    #
-    # @param name [Symbol] The name of the callback
-    # @return [void]
-    def define_callback(name)
-      class_eval <<RUBY
-def on_#{name}(&block)
-  @_sass_callbacks ||= {}
-  (@_sass_callbacks[#{name.inspect}] ||= []) << block
-end
-
-def run_#{name}(*args)
-  return unless @_sass_callbacks
-  return unless @_sass_callbacks[#{name.inspect}]
-  @_sass_callbacks[#{name.inspect}].each {|c| c[*args]}
-end
-private :run_#{name}
-RUBY
-    end
-  end
-end

data/lib/sass/css.rb

@@ -1,294 +0,0 @@
-require File.dirname(__FILE__) + '/../sass'
-require 'sass/tree/node'
-require 'sass/scss/css_parser'
-require 'strscan'
-
-module Sass
-  # This class converts CSS documents into Sass or SCSS templates.
-  # It works by parsing the CSS document into a {Sass::Tree} structure,
-  # and then applying various transformations to the structure
-  # to produce more concise and idiomatic Sass/SCSS.
-  #
-  # Example usage:
-  #
-  #     Sass::CSS.new("p { color: blue }").render(:sass) #=> "p\n  color: blue"
-  #     Sass::CSS.new("p { color: blue }").render(:scss) #=> "p {\n  color: blue; }"
-  class CSS
-    # @param template [String] The CSS stylesheet.
-    #   This stylesheet can be encoded using any encoding
-    #   that can be converted to Unicode.
-    #   If the stylesheet contains an `@charset` declaration,
-    #   that overrides the Ruby encoding
-    #   (see {file:SASS_REFERENCE.md#encodings the encoding documentation})
-    # @option options :old [Boolean] (false)
-    #     Whether or not to output old property syntax
-    #     (`:color blue` as opposed to `color: blue`).
-    #     This is only meaningful when generating Sass code,
-    #     rather than SCSS.
-    def initialize(template, options = {})
-      if template.is_a? IO
-        template = template.read
-      end
-
-      @options = options.dup
-      # Backwards compatibility
-      @options[:old] = true if @options[:alternate] == false
-      @template = template
-    end
-
-    # Converts the CSS template into Sass or SCSS code.
-    #
-    # @param fmt [Symbol] `:sass` or `:scss`, designating the format to return.
-    # @return [String] The resulting Sass or SCSS code
-    # @raise [Sass::SyntaxError] if there's an error parsing the CSS template
-    def render(fmt = :sass)
-      check_encoding!
-      build_tree.send("to_#{fmt}", @options).strip + "\n"
-    rescue Sass::SyntaxError => err
-      err.modify_backtrace(:filename => @options[:filename] || '(css)')
-      raise err
-    end
-
-    # Returns the original encoding of the document,
-    # or `nil` under Ruby 1.8.
-    #
-    # @return [Encoding, nil]
-    # @raise [Encoding::UndefinedConversionError] if the source encoding
-    #   cannot be converted to UTF-8
-    # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
-    def source_encoding
-      check_encoding!
-      @original_encoding
-    end
-
-    private
-
-    def check_encoding!
-      return if @checked_encoding
-      @checked_encoding = true
-      @template, @original_encoding = Haml::Util.check_sass_encoding(@template) do |msg, line|
-        raise Sass::SyntaxError.new(msg, :line => line)
-      end
-    end
-
-    # Parses the CSS template and applies various transformations
-    #
-    # @return [Tree::Node] The root node of the parsed tree
-    def build_tree
-      root = Sass::SCSS::CssParser.new(@template).parse
-      expand_commas      root
-      parent_ref_rules   root
-      remove_parent_refs root
-      flatten_rules      root
-      fold_commas        root
-      root
-    end
-
-    # Transform
-    #
-    #     foo, bar, baz
-    #       color: blue
-    #
-    # into
-    #
-    #     foo
-    #       color: blue
-    #     bar
-    #       color: blue
-    #     baz
-    #       color: blue
-    #
-    # @param root [Tree::Node] The parent node
-    def expand_commas(root)
-      root.children.map! do |child|
-        unless child.is_a?(Tree::RuleNode) && child.rule.first.include?(',')
-          expand_commas(child) if child.is_a?(Tree::DirectiveNode)
-          next child
-        end
-        child.rule.first.split(',').map do |rule|
-          node = Tree::RuleNode.new([rule.strip])
-          node.children = child.children
-          node
-        end
-      end
-      root.children.flatten!
-    end
-
-    # Make rules use parent refs so that
-    #
-    #     foo
-    #       color: green
-    #     foo.bar
-    #       color: blue
-    #
-    # becomes
-    #
-    #     foo
-    #       color: green
-    #       &.bar
-    #         color: blue
-    #
-    # This has the side effect of nesting rules,
-    # so that
-    #
-    #     foo
-    #       color: green
-    #     foo bar
-    #       color: red
-    #     foo baz
-    #       color: blue
-    #
-    # becomes
-    #
-    #     foo
-    #       color: green
-    #       & bar
-    #         color: red
-    #       & baz
-    #         color: blue
-    #
-    # @param root [Tree::Node] The parent node
-    def parent_ref_rules(root)
-      current_rule = nil
-      root.children.map! do |child|
-        unless child.is_a?(Tree::RuleNode)
-          parent_ref_rules(child) if child.is_a?(Tree::DirectiveNode)
-          next child
-        end
-
-        first, rest = child.rule.first.scan(/\A(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?\Z/m).first
-
-        if current_rule.nil? || current_rule.rule.first != first
-          current_rule = Tree::RuleNode.new([first])
-        end
-
-        if rest
-          child.rule = ["&" + rest]
-          current_rule << child
-        else
-          current_rule.children += child.children
-        end
-
-        current_rule
-      end
-      root.children.compact!
-      root.children.uniq!
-
-      root.children.each { |v| parent_ref_rules(v) }
-    end
-
-    # Remove useless parent refs so that
-    #
-    #     foo
-    #       & bar
-    #         color: blue
-    #
-    # becomes
-    #
-    #     foo
-    #       bar
-    #         color: blue
-    #
-    # @param root [Tree::Node] The parent node
-    def remove_parent_refs(root)
-      root.children.each do |child|
-        case child
-        when Tree::RuleNode
-          child.rule.first.gsub! /^& +/, ''
-          remove_parent_refs child
-        when Tree::DirectiveNode
-          remove_parent_refs child
-        end
-      end
-    end
-
-    # Flatten rules so that
-    #
-    #     foo
-    #       bar
-    #         color: red
-    #
-    # becomes
-    #
-    #     foo bar
-    #       color: red
-    #
-    # and
-    #
-    #     foo
-    #       &.bar
-    #         color: blue
-    #
-    # becomes
-    #
-    #     foo.bar
-    #       color: blue
-    #
-    # @param root [Tree::Node] The parent node
-    def flatten_rules(root)
-      root.children.each do |child|
-        case child
-        when Tree::RuleNode
-          flatten_rule(child)
-        when Tree::DirectiveNode
-          flatten_rules(child)
-        end
-      end
-    end
-
-    # Flattens a single rule
-    #
-    # @param rule [Tree::RuleNode] The candidate for flattening
-    # @see #flatten_rules
-    def flatten_rule(rule)
-      while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode)
-        child = rule.children.first
-
-        if child.rule.first[0] == ?&
-          rule.rule = [child.rule.first.gsub(/^&/, rule.rule.first)]
-        else
-          rule.rule = ["#{rule.rule.first} #{child.rule.first}"]
-        end
-
-        rule.children = child.children
-      end
-
-      flatten_rules(rule)
-    end
-
-    # Transform
-    #
-    #     foo
-    #       bar
-    #         color: blue
-    #       baz
-    #         color: blue
-    #
-    # into
-    #
-    #     foo
-    #       bar, baz
-    #         color: blue
-    #
-    # @param rule [Tree::RuleNode] The candidate for flattening
-    def fold_commas(root)
-      prev_rule = nil
-      root.children.map! do |child|
-        unless child.is_a?(Tree::RuleNode)
-          fold_commas(child) if child.is_a?(Tree::DirectiveNode)
-          next child
-        end
-
-        if prev_rule && prev_rule.children == child.children
-          prev_rule.rule.first << ", #{child.rule.first}"
-          next nil
-        end
-
-        fold_commas(child)
-        prev_rule = child
-        child
-      end
-      root.children.compact!
-    end
-  end
-end