torquebox-console 0.2.3 → 0.2.4

data/vendor/bundle/ruby/1.8/gems/haml-3.1.8/vendor/sass/lib/sass/importers.rb

@@ -0,0 +1,22 @@
+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/bundle/ruby/1.8/gems/haml-3.1.8/vendor/sass/lib/sass/importers/base.rb

@@ -0,0 +1,139 @@
+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/bundle/ruby/1.8/gems/haml-3.1.8/vendor/sass/lib/sass/importers/filesystem.rb

@@ -0,0 +1,149 @@
+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/bundle/ruby/1.8/gems/haml-3.1.8/vendor/sass/lib/sass/less.rb

@@ -0,0 +1,382 @@
+#!/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