radiant 1.0.0.rc1 → 1.0.0.rc2

data/vendor/plugins/haml/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/vendor/plugins/haml/lib/sass/callbacks.rbc

@@ -1,388 +0,0 @@
-!RBIX
-17831730954501249321
-x
-M
-1
-n
-n
-x
-10
-__script__
-i
-28
-99
-7
-0
-65
-49
-1
-2
-13
-99
-12
-7
-2
-12
-7
-3
-12
-65
-12
-49
-4
-4
-15
-49
-2
-0
-15
-2
-11
-I
-6
-I
-0
-I
-0
-I
-0
-n
-p
-5
-x
-4
-Sass
-x
-11
-open_module
-x
-15
-__module_init__
-M
-1
-n
-n
-x
-4
-Sass
-i
-28
-5
-66
-99
-7
-0
-65
-49
-1
-2
-13
-99
-12
-7
-2
-12
-7
-3
-12
-65
-12
-49
-4
-4
-15
-49
-2
-0
-11
-I
-6
-I
-0
-I
-0
-I
-0
-n
-p
-5
-x
-9
-Callbacks
-x
-11
-open_module
-x
-15
-__module_init__
-M
-1
-n
-n
-x
-9
-Callbacks
-i
-20
-5
-66
-5
-48
-0
-15
-99
-7
-1
-7
-2
-65
-67
-49
-3
-0
-49
-4
-4
-11
-I
-5
-I
-0
-I
-0
-I
-0
-n
-p
-5
-x
-9
-protected
-x
-15
-define_callback
-M
-1
-n
-n
-x
-15
-define_callback
-i
-61
-5
-7
-0
-20
-0
-47
-101
-1
-7
-2
-20
-0
-49
-3
-0
-47
-101
-1
-7
-4
-20
-0
-47
-101
-1
-7
-5
-20
-0
-49
-3
-0
-47
-101
-1
-7
-6
-20
-0
-49
-3
-0
-47
-101
-1
-7
-7
-20
-0
-47
-101
-1
-7
-8
-63
-13
-47
-49
-9
-1
-11
-I
-f
-I
-1
-I
-1
-I
-1
-n
-p
-10
-s
-7
-def on_
-x
-4
-to_s
-s
-55
-(&block)
-  @_sass_callbacks ||= {}
-  (@_sass_callbacks[
-x
-7
-inspect
-s
-32
-] ||= []) << block
-end
-
-def run_
-s
-74
-(*args)
-  return unless @_sass_callbacks
-  return unless @_sass_callbacks[
-s
-21
-]
-  @_sass_callbacks[
-s
-39
-].each {|c| c[*args]}
-end
-private :run_
-s
-1
-
-
-x
-10
-class_eval
-p
-19
-I
--1
-I
-24
-I
-0
-I
-25
-I
-1
-I
-26
-I
-a
-I
-28
-I
-14
-I
-2b
-I
-1b
-I
-2d
-I
-25
-I
-2e
-I
-2f
-I
-30
-I
-38
-I
-25
-I
-3d
-x
-69
-/Users/jim/Projects/radiant/vendor/plugins/haml/lib/sass/callbacks.rb
-p
-1
-x
-4
-name
-x
-17
-method_visibility
-x
-15
-add_defn_method
-p
-5
-I
-2
-I
-1a
-I
-6
-I
-24
-I
-14
-x
-69
-/Users/jim/Projects/radiant/vendor/plugins/haml/lib/sass/callbacks.rb
-p
-0
-x
-13
-attach_method
-p
-3
-I
-2
-I
-19
-I
-1c
-x
-69
-/Users/jim/Projects/radiant/vendor/plugins/haml/lib/sass/callbacks.rb
-p
-0
-x
-13
-attach_method
-p
-3
-I
-0
-I
-1
-I
-1c
-x
-69
-/Users/jim/Projects/radiant/vendor/plugins/haml/lib/sass/callbacks.rb
-p
-0

data/vendor/plugins/haml/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