radiantcms-couchrest_model 0.1.3 → 0.1.4

data/vendor/plugins/haml/lib/sass/environment.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 module Sass
   # The lexical environment for SassScript.
   # This keeps track of variable and mixin definitions.
@@ -25,8 +23,7 @@ module Sass
       @vars = {}
       @mixins = {}
       @parent = parent
-      @stack = [] unless parent
-      @mixins_in_use = Set.new unless parent
+
       set_var("important", Script::String.new("!important")) unless @parent
     end
 
@@ -38,61 +35,6 @@ module Sass
       @options || (parent && parent.options) || {}
     end
 
-    # Push a new stack frame onto the mixin/include stack.
-    #
-    # @param frame_info [{Symbol => Object}]
-    #   Frame information has the following keys:
-    #
-    #   `:filename`
-    #   : The name of the file in which the lexical scope changed.
-    #
-    #   `:mixin`
-    #   : The name of the mixin in which the lexical scope changed,
-    #     or `nil` if it wasn't within in a mixin.
-    #
-    #   `:line`
-    #   : The line of the file on which the lexical scope changed. Never nil.
-    def push_frame(frame_info)
-      if stack.last && stack.last[:prepared]
-        stack.last.delete(:prepared)
-        stack.last.merge!(frame_info)
-      else
-        stack.push(frame_info)
-      end
-      mixins_in_use << stack.last[:mixin] if stack.last[:mixin] && !stack.last[:prepared]
-    end
-
-    # Like \{#push\_frame}, but next time a stack frame is pushed,
-    # it will be merged with this frame.
-    #
-    # @param frame_info [{Symbol => Object}] Same as for \{#push\_frame}.
-    def prepare_frame(frame_info)
-      push_frame(frame_info.merge(:prepared => true))
-    end
-
-    # Pop a stack frame from the mixin/include stack.
-    def pop_frame
-      stack.pop if stack.last && stack.last[:prepared]
-      popped = stack.pop
-      mixins_in_use.delete(popped[:mixin]) if popped && popped[:mixin]
-    end
-
-    # A list of stack frames in the mixin/include stack.
-    # The last element in the list is the most deeply-nested frame.
-    #
-    # @return [Array<{Symbol => Object}>] The stack frames,
-    #   of the form passed to \{#push\_frame}.
-    def stack
-      @stack ||= @parent.stack
-    end
-
-    # A set of names of mixins currently present in the stack.
-    #
-    # @return [Set<String>] The mixin names.
-    def mixins_in_use
-      @mixins_in_use ||= @parent.mixins_in_use
-    end
-
     class << self
       private
 
@@ -101,16 +43,10 @@ module Sass
       def inherited_hash(name)
         class_eval <<RUBY, __FILE__, __LINE__ + 1
           def #{name}(name)
-            _#{name}(name.gsub('_', '-'))
-          end
-
-          def _#{name}(name)
-            @#{name}s[name] || @parent && @parent._#{name}(name)
+            @#{name}s[name] || @parent && @parent.#{name}(name)
           end
-          protected :_#{name}
 
           def set_#{name}(name, value)
-            name = name.gsub('_', '-')
             @#{name}s[name] = value unless try_set_#{name}(name, value)
           end
 
@@ -127,7 +63,7 @@ module Sass
           protected :try_set_#{name}
 
           def set_local_#{name}(name, value)
-            @#{name}s[name.gsub('_', '-')] = value
+            @#{name}s[name] = value
           end
 RUBY
       end

data/vendor/plugins/haml/lib/sass/error.rb

@@ -4,192 +4,51 @@ module Sass
   # and the Sass file that was being parsed (if applicable).
   #
   # All Sass errors are raised as {Sass::SyntaxError}s.
-  #
-  # When dealing with SyntaxErrors,
-  # it's important to provide filename and line number information.
-  # This will be used in various error reports to users, including backtraces;
-  # see \{#sass\_backtrace} for details.
-  #
-  # Some of this information is usually provided as part of the constructor.
-  # New backtrace entries can be added with \{#add\_backtrace},
-  # which is called when an exception is raised between files (e.g. with `@import`).
-  #
-  # Often, a chunk of code will all have similar backtrace information -
-  # the same filename or even line.
-  # It may also be useful to have a default line number set.
-  # In those situations, the default values can be used
-  # by omitting the information on the original exception,
-  # and then calling \{#modify\_backtrace} in a wrapper `rescue`.
-  # When doing this, be sure that all exceptions ultimately end up
-  # with the information filled in.
   class SyntaxError < StandardError
-    # The backtrace of the error within Sass files.
-    # This is an array of hashes containing information for a single entry.
-    # The hashes have the following keys:
-    #
-    # `:filename`
-    # : The name of the file in which the exception was raised,
-    #   or `nil` if no filename is available.
-    #
-    # `:mixin`
-    # : The name of the mixin in which the exception was raised,
-    #   or `nil` if it wasn't raised in a mixin.
-    #
-    # `:line`
-    # : The line of the file on which the error occurred. Never nil.
-    #
-    # This information is also included in standard backtrace format
-    # in the output of \{#backtrace}.
+    # The line of the Sass template on which the error occurred.
     #
-    # @return [Aray<{Symbol => Object>}]
-    attr_accessor :sass_backtrace
+    # @return [Fixnum]
+    attr_accessor :sass_line
 
-    # The text of the template where this error was raised.
+    # The name of the file that was being parsed when the exception was raised.
+    # This could be `nil` if no filename is available.
     #
     # @return [String]
-    attr_accessor :sass_template
+    attr_reader :sass_filename
 
     # @param msg [String] The error message
-    # @param attrs [{Symbol => Object}] The information in the backtrace entry.
-    #   See \{#sass\_backtrace}
-    def initialize(msg, attrs = {})
+    # @param lineno [Fixnum] See \{#sass\_line}
+    def initialize(msg, lineno = nil)
       @message = msg
-      @sass_backtrace = []
-      add_backtrace(attrs)
-    end
-
-    # The name of the file in which the exception was raised.
-    # This could be `nil` if no filename is available.
-    #
-    # @return [String, nil]
-    def sass_filename
-      sass_backtrace.first[:filename]
-    end
-
-    # The name of the mixin in which the error occurred.
-    # This could be `nil` if the error occurred outside a mixin.
-    #
-    # @return [Fixnum]
-    def sass_mixin
-      sass_backtrace.first[:mixin]
-    end
-
-    # The line of the Sass template on which the error occurred.
-    #
-    # @return [Fixnum]
-    def sass_line
-      sass_backtrace.first[:line]
+      @sass_line = lineno
     end
 
-    # Adds an entry to the exception's Sass backtrace.
+    # Add information about the filename and line on which the error was raised,
+    # and re-raises the exception.
     #
-    # @param attrs [{Symbol => Object}] The information in the backtrace entry.
-    #   See \{#sass\_backtrace}
-    def add_backtrace(attrs)
-      sass_backtrace << attrs.reject {|k, v| v.nil?}
+    # @param filename [String] See \{#sass\_filename}
+    # @param line [Fixnum] See \{#sass\_line}
+    # @raise [Sass::SyntaxError] self
+    def add_metadata(filename, line)
+      self.sass_line ||= line
+      add_backtrace_entry(filename) unless sass_filename
+      raise self
     end
 
-    # Modify the top Sass backtrace entries
-    # (that is, the most deeply nested ones)
-    # to have the given attributes.
+    # Adds a properly formatted entry to the exception's backtrace.
     #
-    # Specifically, this goes through the backtrace entries
-    # from most deeply nested to least,
-    # setting the given attributes for each entry.
-    # If an entry already has one of the given attributes set,
-    # the pre-existing attribute takes precedence
-    # and is not used for less deeply-nested entries
-    # (even if they don't have that attribute set).
-    #
-    # @param attrs [{Symbol => Object}] The information to add to the backtrace entry.
-    #   See \{#sass\_backtrace}
-    def modify_backtrace(attrs)
-      attrs = attrs.reject {|k, v| v.nil?}
-      # Move backwards through the backtrace
-      (0...sass_backtrace.size).to_a.reverse.each do |i|
-        entry = sass_backtrace[i]
-        sass_backtrace[i] = attrs.merge(entry)
-        attrs.reject! {|k, v| entry.include?(k)}
-        break if attrs.empty?
-      end
+    # @param filename [String] 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
 
     # @return [String] The error message
     def to_s
       @message
     end
-
-    # Returns the standard exception backtrace,
-    # including the Sass backtrace.
-    #
-    # @return [Array<String>]
-    def backtrace
-      return nil if super.nil?
-      sass_backtrace.map do |h|
-        "#{h[:filename] || "(sass)"}:#{h[:line]}" +
-          (h[:mixin] ? ":in `#{h[:mixin]}'" : "")
-      end + super
-    end
-
-    # Returns a string representation of the Sass backtrace.
-    #
-    # @param default_filename [String] The filename to use for unknown files
-    # @see #sass_backtrace
-    # @return [String]
-    def sass_backtrace_str(default_filename = "an unknown file")
-      lines = self.message.split("\n")
-      msg = lines[0] + lines[1..-1].
-        map {|l| "\n" + (" " * "Syntax error: ".size) + l}.join
-      "Syntax error: #{msg}" +
-        Haml::Util.enum_with_index(sass_backtrace).map do |entry, i|
-        "\n        #{i == 0 ? "on" : "from"} line #{entry[:line]}" +
-          " of #{entry[:filename] || default_filename}" +
-          (entry[:mixin] ? ", in `#{entry[:mixin]}'" : "")
-      end.join
-    end
-
-    class << self
-      # Returns an error report for an exception in CSS format.
-      #
-      # @param e [Exception]
-      # @param options [{Symbol => Object}] The options passed to {Sass::Engine#initialize}
-      # @return [String] The error report
-      # @raise [Exception] `e`, if the
-      #   {file:SASS_REFERENCE.md#full_exception-option `:full_exception`} option
-      #   is set to false.
-      def exception_to_css(e, options)
-        raise e unless options[:full_exception]
-
-        header = header_string(e, options)
-
-        <<END
-/*
-#{header}
-
-Backtrace:\n#{e.backtrace.join("\n")}
-*/
-body:before {
-  white-space: pre;
-  font-family: monospace;
-  content: "#{header.gsub('"', '\"').gsub("\n", '\\A ')}"; }
-END
-      end
-
-      private
-
-      def header_string(e, options)
-        return "#{e.class}: #{e.message}" unless e.is_a? Sass::SyntaxError
-
-        line_offset = options[:line] || 1
-        line_num = e.sass_line + 1 - line_offset
-        min = [line_num - 6, 0].max
-        section = e.sass_template.rstrip.split("\n")[min ... line_num + 5]
-        return e.sass_backtrace_str if section.nil? || section.empty?
-
-        e.sass_backtrace_str + "\n\n" + Haml::Util.enum_with_index(section).
-          map {|line, i| "#{line_offset + min + i}: #{line}"}.join("\n")
-      end
-    end
   end
 
   # The class for Sass errors that are raised due to invalid unit conversions

data/vendor/plugins/haml/lib/sass/files.rb

@@ -11,18 +11,15 @@ module Sass
     # Returns the {Sass::Tree} for the given file,
     # reading it from the Sass cache if possible.
     #
-    # @param filename [String] The path to the Sass or SCSS file
+    # @param filename [String] The path to the Sass file
     # @param options [{Symbol => Object}] The options hash.
     #   Only the {file:SASS_REFERENCE.md#cache-option `:cache_location`} option is used
-    # @raise [Sass::SyntaxError] if there's an error in the document.
-    #   The caller has responsibility for setting backtrace information, if necessary
+    # @raise [Sass::SyntaxError] if there's an error in the document
     def tree_for(filename, options)
-      default_options = Sass::Engine::DEFAULT_OPTIONS.dup
-      default_options.delete(:syntax)
-      options = default_options.merge!(options)
+      options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
       text = File.read(filename)
 
-      if options[:cache] || options[:read_cache]
+      if options[:cache]
         compiled_filename = sassc_filename(filename, options)
         sha = Digest::SHA1.hexdigest(text)
 
@@ -32,63 +29,57 @@ module Sass
         end
       end
 
-      options = options.merge(:filename => filename)
-      if filename =~ /\.scss$/
-        options = {:syntax => :scss}.merge(options)
-      elsif filename =~ /\.sass$/
-        options = {:syntax => :sass}.merge(options)
-      end
+      engine = Sass::Engine.new(text, options.merge(:filename => filename))
 
-      engine = Sass::Engine.new(text, options)
+      begin
+        root = engine.to_tree
+      rescue Sass::SyntaxError => err
+        err.add_backtrace_entry(filename)
+        raise err
+      end
 
-      root = engine.to_tree
       try_to_write_sassc(root, compiled_filename, sha, options) if options[:cache]
+
       root
     end
 
-    # Find the full filename of a Sass, SCSS, or CSS file to import.
+    # Find the full filename of a Sass or CSS file to import.
     # This follows Sass's import rules:
-    # if the filename given ends in `".sass"`, `".scss"`, or `".css"`,
+    # if the filename given ends in `".sass"` or `".css"`,
     # it will try to find that type of file;
-    # otherwise, it will try to find the corresponding Sass/SCSS file
+    # otherwise, it will try to find the corresponding Sass file
     # and fall back on CSS if it's not available.
     #
-    # Any Sass/SCSS filename returned will correspond to
-    # an actual file of the corresponding type on the filesystem.
+    # Any Sass filename returned will correspond to
+    # an actual Sass file on the filesystem.
     # CSS filenames, however, may not;
     # they're expected to be put through directly to the stylesheet
     # as CSS `@import` statements.
     #
     # @param filename [String] The filename to search for
     # @param load_paths [Array<String>] The set of filesystem paths
-    #   to search for Sass/SCSS files.
+    #   to search for Sass files.
     # @return [String] The filename of the imported file.
-    #   This is an absolute path if the file is a `".sass"` or `".scss"` file.
-    # @raise [Sass::SyntaxError] if `filename` ends in `".sass"` or `".scss"`
-    #   and no corresponding Sass/SCSS file could be found.
+    #   This is an absolute path if the file is a `".sass"` file.
+    # @raise [Sass::SyntaxError] if `filename` ends in ``".sass"``
+    #   and no corresponding Sass file could be found.
     def find_file_to_import(filename, load_paths)
-      was_sass = was_scss = false
+      was_sass = false
       original_filename = filename
 
-      if [".sass", ".scss"].include?(filename[-5..-1])
-        was_sass = filename[-5..-1] == ".sass"
-        was_scss = filename[-5..-1] == ".scss"
+      if filename[-5..-1] == ".sass"
         filename = filename[0...-5]
+        was_sass = true
       elsif filename[-4..-1] == ".css"
         return filename
       end
 
-      new_filename = nil
-      load_paths = load_paths.uniq
-      load_paths.each do |load_path|
-        new_filename ||= find_full_path("#{filename}.sass", load_path) unless was_scss
-        new_filename ||= find_full_path("#{filename}.scss", load_path) unless was_sass
-      end
+      new_filename = find_full_path("#{filename}.sass", load_paths)
 
       return new_filename if new_filename
-      unless was_sass || was_scss
-        Haml::Util.haml_warn <<END
-WARNING: Neither #{filename}.sass nor .scss found. Using #{filename}.css instead.
+      unless was_sass
+        warn <<END
+WARNING: #{filename}.sass not found. Using #{filename}.css instead.
 This behavior is deprecated and will be removed in a future version.
 If you really need #{filename}.css, import it explicitly.
 END
@@ -102,7 +93,7 @@ END
         message << "Load paths:\n  " << load_paths.join("\n  ")
       end
 
-      raise SyntaxError.new(message)
+      raise SyntaxError.new(message, @line)
     end
 
     private
@@ -122,7 +113,7 @@ END
         return Marshal.load(f.read)
       end
     rescue EOFError, TypeError, ArgumentError => e
-      Haml::Util.haml_warn "Warning. Error encountered while reading cache #{compiled_filename}: #{e}"
+      warn "Warning. Error encountered while reading cache #{compiled_filename}: #{e}"
     end
 
     def try_to_write_sassc(root, compiled_filename, sha, options)
@@ -140,7 +131,7 @@ END
       end
     end
 
-    def find_full_path(filename, load_path)
+    def find_full_path(filename, load_paths)
       partial_name = File.join(File.dirname(filename), "_#{File.basename(filename)}")
 
       if Pathname.new(filename).absolute?
@@ -150,9 +141,13 @@ END
         return nil
       end
 
-      [partial_name, filename].each do |name|
-        full_path = File.join(load_path, name)
-        return full_path if File.readable?(full_path)
+      load_paths.each do |path|
+        [partial_name, filename].each do |name|
+          full_path = File.join(path, name)
+          if File.readable?(full_path)
+            return full_path
+          end
+        end
       end
       nil
     end