haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/vendor/sass/lib/sass/importers.rb

@@ -1,22 +0,0 @@
-module Sass
-  # Sass importers are in charge of taking paths passed to `@import`
-  # and finding the appropriate Sass code for those paths.
-  # By default, this code is always loaded from the filesystem,
-  # but importers could be added to load from a database or over HTTP.
-  #
-  # Each importer is in charge of a single load path
-  # (or whatever the corresponding notion is for the backend).
-  # Importers can be placed in the {file:SASS_REFERENCE.md#load_paths-option `:load_paths` array}
-  # alongside normal filesystem paths.
-  #
-  # When resolving an `@import`, Sass will go through the load paths
-  # looking for an importer that successfully imports the path.
-  # Once one is found, the imported file is used.
-  #
-  # User-created importers must inherit from {Importers::Base}.
-  module Importers
-  end
-end
-
-require 'sass/importers/base'
-require 'sass/importers/filesystem'

data/vendor/sass/lib/sass/importers/base.rb

@@ -1,139 +0,0 @@
-module Sass
-  module Importers
-    # The abstract base class for Sass importers.
-    # All importers should inherit from this.
-    #
-    # At the most basic level, an importer is given a string
-    # and must return a {Sass::Engine} containing some Sass code.
-    # This string can be interpreted however the importer wants;
-    # however, subclasses are encouraged to use the URI format
-    # for pathnames.
-    #
-    # Importers that have some notion of "relative imports"
-    # should take a single load path in their constructor,
-    # and interpret paths as relative to that.
-    # They should also implement the \{#find\_relative} method.
-    #
-    # Importers should be serializable via `Marshal.dump`.
-    # In addition to the standard `_dump` and `_load` methods,
-    # importers can define `_before_dump`, `_after_dump`, `_around_dump`,
-    # and `_after_load` methods as per {Sass::Util#dump} and {Sass::Util#load}.
-    #
-    # @abstract
-    class Base
-
-      # Find a Sass file relative to another file.
-      # Importers without a notion of "relative paths"
-      # should just return nil here.
-      #
-      # If the importer does have a notion of "relative paths",
-      # it should ignore its load path during this method.
-      #
-      # See \{#find} for important information on how this method should behave.
-      #
-      # The `:filename` option passed to the returned {Sass::Engine}
-      # should be of a format that could be passed to \{#find}.
-      #
-      # @param uri [String] The URI to import. This is not necessarily relative,
-      #   but this method should only return true if it is.
-      # @param base [String] The base filename. If `uri` is relative,
-      #   it should be interpreted as relative to `base`.
-      #   `base` is guaranteed to be in a format importable by this importer.
-      # @param options [{Symbol => Object}] Options for the Sass file
-      #   containing the `@import` that's currently being resolved.
-      # @return [Sass::Engine, nil] An Engine containing the imported file,
-      #   or nil if it couldn't be found or was in the wrong format.
-      def find_relative(uri, base, options)
-        Sass::Util.abstract(self)
-      end
-
-      # Find a Sass file, if it exists.
-      #
-      # This is the primary entry point of the Importer.
-      # It corresponds directly to an `@import` statement in Sass.
-      # It should do three basic things:
-      #
-      # * Determine if the URI is in this importer's format.
-      #   If not, return nil.
-      # * Determine if the file indicated by the URI actually exists and is readable.
-      #   If not, return nil.
-      # * Read the file and place the contents in a {Sass::Engine}.
-      #   Return that engine.
-      #
-      # If this importer's format allows for file extensions,
-      # it should treat them the same way as the default {Filesystem} importer.
-      # If the URI explicitly has a `.sass` or `.scss` filename,
-      # the importer should look for that exact file
-      # and import it as the syntax indicated.
-      # If it doesn't exist, the importer should return nil.
-      #
-      # If the URI doesn't have either of these extensions,
-      # the importer should look for files with the extensions.
-      # If no such files exist, it should return nil.
-      #
-      # The {Sass::Engine} to be returned should be passed `options`,
-      # with a few modifications. `:syntax` should be set appropriately,
-      # `:filename` should be set to `uri`,
-      # and `:importer` should be set to this importer.
-      #
-      # @param uri [String] The URI to import.
-      # @param options [{Symbol => Object}] Options for the Sass file
-      #   containing the `@import` that's currently being resolved.
-      #   This is safe for subclasses to modify destructively.
-      #   Callers should only pass in a value they don't mind being destructively modified.
-      # @return [Sass::Engine, nil] An Engine containing the imported file,
-      #   or nil if it couldn't be found or was in the wrong format.
-      def find(uri, options)
-        Sass::Util.abstract(self)
-      end
-
-      # Returns the time the given Sass file was last modified.
-      #
-      # If the given file has been deleted or the time can't be accessed
-      # for some other reason, this should return nil.
-      #
-      # @param uri [String] The URI of the file to check.
-      #   Comes from a `:filename` option set on an engine returned by this importer.
-      # @param options [{Symbol => Objet}] Options for the Sass file
-      #   containing the `@import` currently being checked.
-      # @return [Time, nil]
-      def mtime(uri, options)
-        Sass::Util.abstract(self)
-      end
-
-      # Get the cache key pair for the given Sass URI.
-      # The URI need not be checked for validity.
-      #
-      # The only strict requirement is that the returned pair of strings
-      # uniquely identify the file at the given URI.
-      # However, the first component generally corresponds roughly to the directory,
-      # and the second to the basename, of the URI.
-      #
-      # Note that keys must be unique *across importers*.
-      # Thus it's probably a good idea to include the importer name
-      # at the beginning of the first component.
-      #
-      # @param uri [String] A URI known to be valid for this importer.
-      # @param options [{Symbol => Object}] Options for the Sass file
-      #   containing the `@import` currently being checked.
-      # @return [(String, String)] The key pair which uniquely identifies
-      #   the file at the given URI.
-      def key(uri, options)
-        Sass::Util.abstract(self)
-      end
-
-      # A string representation of the importer.
-      # Should be overridden by subclasses.
-      #
-      # This is used to help debugging,
-      # and should usually just show the load path encapsulated by this importer.
-      #
-      # @return [String]
-      def to_s
-        Sass::Util.abstract(self)
-      end
-    end
-  end
-end
-
-      

data/vendor/sass/lib/sass/importers/filesystem.rb

@@ -1,149 +0,0 @@
-require 'pathname'
-
-module Sass
-  module Importers
-    # The default importer, used for any strings found in the load path.
-    # Simply loads Sass files from the filesystem using the default logic.
-    class Filesystem < Base
-
-      attr_accessor :root
-
-      # Creates a new filesystem importer that imports files relative to a given path.
-      #
-      # @param root [String] The root path.
-      #   This importer will import files relative to this path.
-      def initialize(root)
-        @root = File.expand_path(root)
-      end
-
-      # @see Base#find_relative
-      def find_relative(name, base, options)
-        _find(File.dirname(base), name, options)
-      end
-
-      # @see Base#find
-      def find(name, options)
-        _find(@root, name, options)
-      end
-
-      # @see Base#mtime
-      def mtime(name, options)
-        file, s = find_real_file(@root, name)
-        File.mtime(file) if file
-      rescue Errno::ENOENT
-        nil
-      end
-
-      # @see Base#key
-      def key(name, options)
-        [self.class.name + ":" + File.dirname(File.expand_path(name)),
-          File.basename(name)]
-      end
-
-      # @see Base#to_s
-      def to_s
-        @root
-      end
-
-      def hash
-        @root.hash
-      end
-
-      def eql?(other)
-        root.eql?(other.root)
-      end
-
-      protected
-
-      # If a full uri is passed, this removes the root from it
-      # otherwise returns the name unchanged
-      def remove_root(name)
-        if name.index(@root + "/") == 0
-          name[(@root.length + 1)..-1]
-        else
-          name
-        end
-      end
-
-      # A hash from file extensions to the syntaxes for those extensions.
-      # The syntaxes must be `:sass` or `:scss`.
-      #
-      # This can be overridden by subclasses that want normal filesystem importing
-      # with unusual extensions.
-      #
-      # @return [{String => Symbol}]
-      def extensions
-        {'sass' => :sass, 'scss' => :scss}
-      end
-
-      # Given an `@import`ed path, returns an array of possible
-      # on-disk filenames and their corresponding syntaxes for that path.
-      #
-      # @param name [String] The filename.
-      # @return [Array(String, Symbol)] An array of pairs.
-      #   The first element of each pair is a filename to look for;
-      #   the second element is the syntax that file would be in (`:sass` or `:scss`).
-      def possible_files(name)
-        name = escape_glob_characters(name)
-        dirname, basename, extname = split(name)
-        sorted_exts = extensions.sort
-        syntax = extensions[extname]
-
-        return [["#{dirname}/{_,}#{basename}.#{extensions.invert[syntax]}", syntax]] if syntax
-        sorted_exts.map {|ext, syn| ["#{dirname}/{_,}#{basename}.#{ext}", syn]}
-      end
-
-      def escape_glob_characters(name)
-        name.gsub(/[\*\[\]\{\}\?]/) do |char|
-          "\\#{char}"
-        end
-      end
-
-      REDUNDANT_DIRECTORY = %r{#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}}
-      # Given a base directory and an `@import`ed name,
-      # finds an existant file that matches the name.
-      #
-      # @param dir [String] The directory relative to which to search.
-      # @param name [String] The filename to search for.
-      # @return [(String, Symbol)] A filename-syntax pair.
-      def find_real_file(dir, name)
-        for (f,s) in possible_files(remove_root(name))
-          path = (dir == "." || Pathname.new(f).absolute?) ? f : "#{dir}/#{f}"
-          if full_path = Dir[path].first
-            full_path.gsub!(REDUNDANT_DIRECTORY,File::SEPARATOR)
-            return full_path, s
-          end
-        end
-        nil
-      end
-
-      # Splits a filename into three parts, a directory part, a basename, and an extension
-      # Only the known extensions returned from the extensions method will be recognized as such.
-      def split(name)
-        extension = nil
-        dirname, basename = File.dirname(name), File.basename(name)
-        if basename =~ /^(.*)\.(#{extensions.keys.map{|e| Regexp.escape(e)}.join('|')})$/
-          basename = $1
-          extension = $2
-        end
-        [dirname, basename, extension]
-      end
-
-      private
-
-      def _find(dir, name, options)
-        full_filename, syntax = find_real_file(dir, name)
-        return unless full_filename && File.readable?(full_filename)
-
-        options[:syntax] = syntax
-        options[:filename] = full_filename
-        options[:importer] = self
-        Sass::Engine.new(File.read(full_filename), options)
-      end
-
-      def join(base, path)
-        Pathname.new(base).join(path).to_s
-      end
-    end
-  end
-end

data/vendor/sass/lib/sass/less.rb

@@ -1,382 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'less'
-
-module Less
-  # This is the class that Treetop defines for parsing Less files.
-  # Since not everything gets parsed into the AST but is instead resolved at parse-time,
-  # we need to override some of it so that it can be converted into Sass.
-  module StyleSheet
-    # Selector mixins that don't have arguments.
-    # This depends only on the syntax at the call site;
-    # if it doesn't use parens, it hits this production,
-    # regardless of whether the mixin being called has arguments or not.
-    module Mixin4
-      def build_with_sass(env)
-        selectors.build(env, :mixin).each do |path|
-          el = path.inject(env.root) do |current, node|
-            current.descend(node.selector, node) or raise MixinNameError, "#{selectors.text_value} in #{env}"
-          end
-          if el.is_a?(Node::Mixin::Def)
-            # Calling a mixin with arguments, which gets compiled to a Sass mixin
-            env << Node::Mixin::Call.new(el, [], env)
-          else
-            # Calling a mixin without arguments, which gets compiled to @extend
-            sel = selector_str(path)
-            base = selector_str(selector_base(path))
-            if base == sel
-              env << Node::SassNode.new(Sass::Tree::ExtendNode.new([sel]))
-            else
-              Sass::Util.sass_warn <<WARNING
-WARNING: Sass doesn't support mixing in selector sequences.
-Replacing "#{sel}" with "@extend #{base}"
-WARNING
-              env << Node::SassNode.new(Sass::Tree::CommentNode.new(["// #{sel};"], true, false))
-              env << Node::SassNode.new(Sass::Tree::ExtendNode.new([base]))
-            end
-          end
-        end
-      end
-      alias_method :build_without_sass, :build
-      alias_method :build, :build_with_sass
-
-      def selector_base(path)
-        el, i = Sass::Util.enum_with_index(path).to_a.reverse.find {|e, i| e.selector !~ /^:{1,2}$/} ||
-          [path.first, 0]
-        sel = (el.selector =~ /^:{0,2}$/ ? el.selector : "")
-        [Node::Element.new(el.name, sel)] + path[i+1..-1]
-      end
-
-      def selector_str(path)
-        path.map {|e| e.sass_selector_str}.join(' ').gsub(' :', ':')
-      end
-    end
-
-    # Property and variable declarations.
-    # We want to keep track of the line number
-    # so we don't space out the variables too much in the generated Sass.
-    module Declaration3
-      def build_with_sass(env)
-        build_without_sass(env)
-        env.rules.last.src_line = input.line_of(interval.first)
-      end
-      alias_method :build_without_sass, :build
-      alias_method :build, :build_with_sass
-    end
-
-    # Comma-separated selectors.
-    # Less breaks these into completely separate nodes.
-    # Since we don't want this duplication in the Sass,
-    # we modify the production to keep track of the original group
-    # so we can reconstruct it later on.
-    module Selectors2
-      def build_with_sass(env, method)
-        arr = build_without_sass(env, method)
-        return arr if method == :mixin
-        rarr = arr.map {|e| e.top(env)}
-        rarr.each {|e| e.group = rarr}
-        arr
-      end
-      alias_method :build_without_sass, :build
-      alias_method :build, :build_with_sass
-    end
-
-    # Attribute accessors.
-    # Sass just flat-out doesn't support these,
-    # so we print a warning to that effect and compile them to comments.
-    module Accessor1
-      def build(env)
-        Sass::Util.sass_warn <<WARNING
-WARNING: Sass doesn't support attribute accessors.
-Ignoring #{text_value}
-WARNING
-        Node::Anonymous.new("/* #{text_value} */")
-      end
-    end
-
-    # @import statements.
-    # Less handles these during parse-time,
-    # so we want to wrap them up as a node in the tree.
-    # We also include the nodes, though,
-    # since we want to have access to the mixins
-    # so we can tell if they take arguments or not.
-    # The included nodes are hidden so they don't appear in the output.
-    module Import1
-      def build_with_sass(env)
-        line = input.line_of(interval.first)
-        import = Sass::Tree::ImportNode.new(url.value.gsub(/\.less$/, ''))
-        import.line = input.line_of(interval.first)
-        env << Node::SassNode.new(import)
-        old_rules = env.rules.dup
-        build_without_sass env
-        (env.rules - old_rules).each {|r| r.hide_in_sass = true}
-      rescue ImportError => e
-        raise Sass::SyntaxError.new("File to import #{url.text_value} not found or unreadable", :line => line)
-      end
-      alias_method :build_without_sass, :build
-      alias_method :build, :build_with_sass
-    end
-
-    # The IE-specific `alpha(opacity=@var)`.
-    # Less manually resolves the variable here at parse-time.
-    # We want to keep the variable around,
-    # so we compile this to a function.
-    # Less doesn't actually have an `=` operator,
-    # but that's okay since it's just getting compiled to Sass anyway.
-    module Entity::Alpha1
-      def build(env)
-        Node::Function.new("alpha",
-          [Node::Expression.new([
-                Node::Keyword.new("opacity"),
-                Node::Operator.new("="),
-                variable.build])])
-      end
-    end
-  end
-
-  # The Less AST classes for the document,
-  # including both stylesheet-level nodes and expression-level nodes.
-  # The main purpose of overriding these is to add `#to_sass_tree` functions
-  # for converting to Sass.
-  module Node
-    module Entity
-      attr_accessor :hide_in_sass
-      attr_accessor :src_line
-    end
-
-    class Element
-      attr_accessor :group
-
-      def top(env)
-        return self if parent.equal?(env)
-        return parent.top(env)
-      end
-
-      def to_sass_tree
-        if root?
-          root = Sass::Tree::RootNode.new("")
-          rules.each {|r| root << r.to_sass_tree}
-          return root
-        end
-        return if hide_in_sass
-        return if !self.equal?(group.first)
-
-        last_el = nil
-        sel = group.map do |el|
-          comma_sel = []
-          loop do
-            comma_sel << el.sass_selector_str
-            break unless el.rules.size == 1 && el.rules.first.is_a?(Element)
-            el = el.rules.first
-          end
-          last_el = el
-          comma_sel = comma_sel.join(' ').gsub(' :', ':')
-          comma_sel.gsub!(/^:/, '&:') unless parent.root?
-          comma_sel
-        end.join(', ')
-
-        rule = Sass::Tree::RuleNode.new([sel])
-        last_el.rules.each {|r| rule << r.to_sass_tree}
-        return rule
-      end
-
-      def sass_selector_str
-        case @selector
-        when /[+>~]/; "#{@selector} #{@name}"
-        else @selector + @name
-        end
-      end
-    end
-
-    module Mixin
-      class Call
-        def to_sass_tree
-          return if hide_in_sass
-          Sass::Tree::MixinNode.new(@mixin.name.gsub(/^\./, ''), @params.map {|v| v.to_sass_tree}, {})
-        end
-      end
-
-      class Def
-        def to_sass_tree
-          return if hide_in_sass
-          mixin = Sass::Tree::MixinDefNode.new(name, @params.map do |v|
-              v.value.flatten!
-              [Sass::Script::Variable.new(v), v.value.to_sass_tree]
-            end)
-          rules.each {|r| mixin << r.to_sass_tree}
-          mixin
-        end
-      end
-    end
-
-    class SassNode
-      include Entity
-
-      def initialize(node)
-        @node = node
-      end
-
-      def to_sass_tree
-        return if hide_in_sass
-        @node
-      end
-    end
-
-    class Property
-      def to_sass_tree
-        return if hide_in_sass
-        Sass::Tree::PropNode.new([self], @value.to_sass_tree, :new)
-      end
-    end
-
-    class Expression
-      def to_sass_tree
-        if first.is_a?(Array)
-          val = map {|e| _to_sass_tree(e)}.inject(nil) do |e, i|
-            next i unless e
-            Sass::Script::Operation.new(e, i, :comma)
-          end
-        else
-          val = _to_sass_tree(self)
-        end
-        val.options = {}
-        val
-      end
-
-      private
-
-      LESS_TO_SASS_OPERATORS = {"-" => :minus, "+" => :plus, "*" => :times, "/" => :div, "=" => :single_eq}
-
-      def _to_sass_tree(arr)
-        e, rest = _to_sass_tree_plus_minus_eq(arr)
-        until rest.empty?
-          e2, rest = _to_sass_tree_plus_minus_eq(rest)
-          e = Sass::Script::Operation.new(e, e2, :space)
-        end
-        return e
-      end
-
-      def _to_sass_tree_plus_minus_eq(arr)
-        e, rest = _to_sass_tree_times_div(arr)
-        while rest[0] && rest[0].is_a?(Operator) && %w[+ - =].include?(rest[0])
-          op = LESS_TO_SASS_OPERATORS[rest[0]]
-          e2, rest = _to_sass_tree_times_div(rest[1..-1])
-          e = Sass::Script::Operation.new(e, e2, op)
-        end
-        return e, rest
-      end
-
-      def _to_sass_tree_times_div(arr)
-        e, rest = _to_sass_tree_unary(arr)
-        while rest[0] && rest[0].is_a?(Operator) && %w[* /].include?(rest[0])
-          op = LESS_TO_SASS_OPERATORS[rest[0]]
-          e2, rest = _to_sass_tree_unary(rest[1..-1])
-          e = Sass::Script::Operation.new(e, e2, op)
-        end
-        return e, rest
-      end
-
-      def _to_sass_tree_unary(arr)
-        if arr[0] == "-"
-          first, rest = _sass_split(arr[1..-1])
-          return Sass::Script::UnaryOperation.new(first, :minus), rest
-        else
-          return _sass_split(arr[0..-1])
-        end
-      end
-
-      def _sass_split(arr)
-        return arr[0].to_sass_tree, arr[1..-1] unless arr[0] == "("
-        parens = 1
-        i = arr[1..-1].each_with_index do |e, i|
-          parens += 1 if e == "("
-          parens -= 1 if e == ")"
-          break i if parens == 0
-        end
-
-        return _to_sass_tree(arr[1...i+1]), arr[i+2..-1]
-      end
-    end
-
-    class Color
-      def to_sass_tree
-        Sass::Script::Color.new(:red => r, :green => g, :blue => b, :alpha => a)
-      end
-    end
-
-    class Number
-      def to_sass_tree
-        Sass::Script::Number.new(self, [self.unit])
-      end
-    end
-
-    class Variable
-      def to_sass_tree
-        if @declaration
-          return if hide_in_sass
-          node = Sass::Tree::VariableNode.new(self, @value.to_sass_tree, false)
-          node.line = self.src_line
-          node
-        else
-          Sass::Script::Variable.new(self)
-        end
-      end
-    end
-
-    class Function
-      def to_sass_tree
-        Sass::Script::Funcall.new(self, @args.map {|a| a.to_sass_tree}, {})
-      end
-    end
-
-    class Keyword
-      def to_sass_tree
-        Sass::Script::String.new(self)
-      end
-    end
-
-    class Anonymous
-      def to_sass_tree
-        Sass::Script::String.new(self)
-      end
-    end
-
-    class Quoted
-      def to_sass_tree
-        Sass::Script::String.new(self, true)
-      end
-    end
-
-    class FontFamily
-      def to_sass_tree
-        @family.map {|f| f.to_sass_tree}.inject(nil) do |e, f|
-          next f unless e
-          Sass::Script::Operation.new(e, f, :comma)
-        end
-      end
-    end
-  end
-
-  # The entry point to Less.
-  # By default Less doesn't preserve the filename of the file being parsed,
-  # which is unpleasant for error reporting.
-  # Our monkeypatch keeps it around.
-  class Engine
-    def initialize_with_sass(obj, opts = {})
-      initialize_without_sass(obj, opts)
-      @filename = obj.path if obj.is_a?(File)
-    end
-    alias_method :initialize_without_sass, :initialize
-    alias_method :initialize, :initialize_with_sass
-
-    def parse_with_sass
-      parse_without_sass
-    rescue Sass::SyntaxError => e
-      e.modify_backtrace(:filename => @filename)
-      raise e
-    end
-    alias_method :parse_without_sass, :parse
-    alias_method :parse, :parse_with_sass
-    alias_method :to_tree, :parse
-  end
-end