merbjedi-haml 2.1.0

data/lib/sass/environment.rb

@@ -0,0 +1,33 @@
+module Sass
+  class Environment
+    attr_reader :parent
+
+    def initialize(parent = nil)
+      @vars = {}
+      @mixins = {}
+      @parent = parent
+    end
+
+    def self.inherited_hash(name)
+      class_eval <<RUBY, __FILE__, __LINE__ + 1
+        def #{name}(name)
+          @#{name}s[name] || @parent && @parent.#{name}(name)
+        end
+
+        def set_#{name}(name, value)
+          if @parent && @parent.#{name}(name)
+            @parent.set_#{name}(name, value)
+          else
+            @#{name}s[name] = value
+          end
+        end
+
+        def set_local_#{name}(name, value)
+          @#{name}s[name] = value
+        end
+RUBY
+    end
+    inherited_hash :var
+    inherited_hash :mixin
+  end
+end

data/lib/sass/error.rb

@@ -0,0 +1,35 @@
+module Sass
+  # Sass::SyntaxError encapsulates information about the exception,
+  # such as the line of the Sass template it was raised on
+  # and the Sass file that was being parsed (if applicable).
+  # It also provides a handy way to rescue only exceptions raised
+  # because of a faulty template.
+  class SyntaxError < StandardError
+    # The line of the Sass template on which the exception was thrown.
+    attr_accessor :sass_line
+
+    # The name of the file that was being parsed when the exception was raised.
+    # This will be nil unless Sass is being used as an ActionView plugin.
+    attr_reader :sass_filename
+
+    # Creates a new SyntaxError.
+    # +lineno+ should be the line of the Sass template on which the error occurred.
+    def initialize(msg, lineno = nil)
+      @message = msg
+      @sass_line = lineno
+    end
+
+    # Adds a properly formatted entry to the exception's backtrace.
+    # +filename+ should be 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
+
+    def to_s # :nodoc:
+      @message
+    end
+  end
+end

data/lib/sass/plugin.rb

@@ -0,0 +1,203 @@
+require 'sass/engine'
+require 'pathname'
+
+module Sass
+  # This module contains methods to aid in using Sass
+  # as a stylesheet-rendering plugin for various systems.
+  # Currently Rails/ActionController and Merb are supported out of the box.
+  module Plugin
+    class << self
+      @@options = {
+        :css_location       => './public/stylesheets',
+        :always_update      => false,
+        :always_check       => true,
+        :full_exception     => true
+      }
+      @@checked_for_updates = false
+
+      # Whether or not Sass has *ever* checked if the stylesheets need updates
+      # (in this Ruby instance).
+      def checked_for_updates
+        @@checked_for_updates
+      end
+
+      # Gets various options for Sass. See README.rdoc for details.
+      #--
+      # TODO: *DOCUMENT OPTIONS*
+      #++
+      def options
+        @@options
+      end
+
+      # Sets various options for Sass.
+      def options=(value)
+        @@options.merge!(value)
+      end
+
+      # Get the options ready to be passed to the Sass::Engine
+      def engine_options(additional_options = {})
+        opts = options.dup.merge(additional_options)
+        opts[:load_paths] = load_paths(opts)
+        opts
+      end
+
+      # Checks each stylesheet in <tt>options[:css_location]</tt>
+      # to see if it needs updating,
+      # and updates it using the corresponding template
+      # from <tt>options[:templates]</tt>
+      # if it does.
+      def update_stylesheets
+        return if options[:never_update]
+
+        @@checked_for_updates = true
+        template_locations.zip(css_locations).each do |template_location, css_location|
+
+          Dir.glob(File.join(template_location, "**", "*.sass")).each do |file|
+            # Get the relative path to the file with no extension
+            name = file.sub(template_location + "/", "")[0...-5]
+
+            if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name, template_location, css_location))
+              update_stylesheet(name, template_location, css_location)
+            end
+          end
+        end
+      end
+
+      private
+
+      def update_stylesheet(name, template_location, css_location)
+        css = css_filename(name, css_location)
+        File.delete(css) if File.exists?(css)
+
+        filename = template_filename(name, template_location)
+        engine = Engine.new(File.read(filename), engine_options(:css_filename => css, :filename => filename))
+        result = begin
+                   engine.render
+                 rescue Exception => e
+                   exception_string(e)
+                 end
+
+        # Create any directories that might be necessary
+        mkpath(css_location, name)
+
+        # Finally, write the file
+        File.open(css, 'w') do |file|
+          file.print(result)
+        end
+      end
+      
+      # Create any successive directories required to be able to write a file to: File.join(base,name)
+      def mkpath(base, name)
+        dirs = [base]
+        name.split(File::SEPARATOR)[0...-1].each { |dir| dirs << File.join(dirs[-1],dir) }
+        dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
+      end
+
+      def load_paths(opts = options)
+        (opts[:load_paths] || []) + template_locations
+      end
+      
+      def template_locations
+        location = (options[:template_location] || File.join(options[:css_location],'sass'))
+        if location.is_a?(String)
+          [location]
+        else
+          location.to_a.map { |l| l.first }
+        end
+      end
+      
+      def css_locations
+        if options[:template_location] && !options[:template_location].is_a?(String)
+          options[:template_location].to_a.map { |l| l.last }
+        else
+          [options[:css_location]]
+        end
+      end
+
+      def exception_string(e)
+        if options[:full_exception]
+          e_string = "#{e.class}: #{e.message}"
+
+          if e.is_a? Sass::SyntaxError
+            e_string << "\non line #{e.sass_line}"
+
+            if e.sass_filename
+              e_string << " of #{e.sass_filename}"
+
+              if File.exists?(e.sass_filename)
+                e_string << "\n\n"
+
+                min = [e.sass_line - 5, 0].max
+                begin
+                  File.read(e.sass_filename).rstrip.split("\n")[
+                    min .. e.sass_line + 5
+                  ].each_with_index do |line, i|
+                    e_string << "#{min + i + 1}: #{line}\n"
+                  end
+                rescue
+                  e_string << "Couldn't read sass file: #{e.sass_filename}"
+                end
+              end
+            end
+          end
+          <<END
+/*
+#{e_string}
+
+Backtrace:\n#{e.backtrace.join("\n")}
+*/
+body:before {
+  white-space: pre;
+  font-family: monospace;
+  content: "#{e_string.gsub('"', '\"').gsub("\n", '\\A ')}"; }
+END
+          # Fix an emacs syntax-highlighting hiccup: '
+        else
+          "/* Internal stylesheet error */"
+        end
+      end
+
+      def template_filename(name, path)
+        "#{path}/#{name}.sass"
+      end
+
+      def css_filename(name, path)
+        "#{path}/#{name}.css"
+      end
+
+      def forbid_update?(name)
+        name.sub(/^.*\//, '')[0] == ?_
+      end
+
+      def stylesheet_needs_update?(name, template_path, css_path)
+        css_file = css_filename(name, css_path)
+        template_file = template_filename(name, template_path)
+        if !File.exists?(css_file)
+          return true
+        else
+          css_mtime = File.mtime(css_file)
+          File.mtime(template_file) > css_mtime ||
+            dependencies(template_file).any?(&dependency_updated?(css_mtime))
+        end
+      end
+
+      def dependency_updated?(css_mtime)
+        lambda do |dep|
+          File.mtime(dep) > css_mtime ||
+            dependencies(dep).any?(&dependency_updated?(css_mtime))
+        end
+      end
+
+      def dependencies(filename)
+        File.readlines(filename).grep(/^@import /).map do |line|
+          line[8..-1].split(',').map do |inc|
+            Sass::Engine.find_file_to_import(inc.strip, [File.dirname(filename)] + load_paths)
+          end
+        end.flatten.grep(/\.sass$/)
+      end
+    end
+  end
+end
+
+require 'sass/plugin/rails' if defined?(ActionController)
+require 'sass/plugin/merb'  if defined?(Merb::Plugins)

data/lib/sass/plugin/merb.rb

@@ -0,0 +1,56 @@
+unless defined?(Sass::MERB_LOADED)
+  Sass::MERB_LOADED = true
+
+  version = Merb::VERSION.split('.').map { |n| n.to_i }
+  if version[0] <= 0 && version[1] < 5
+    root = MERB_ROOT
+    env  = MERB_ENV
+  else
+    root = Merb.root.to_s
+    env  = Merb.environment
+  end
+
+  Sass::Plugin.options.merge!(:template_location  => root + '/public/stylesheets/sass',
+                              :css_location       => root + '/public/stylesheets',
+                              :always_check       => env != "production",
+                              :full_exception     => env != "production")
+  config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
+
+  if defined? config.symbolize_keys!
+    config.symbolize_keys!
+  end
+
+  Sass::Plugin.options.merge!(config)
+
+  if version[0] > 0 || version[1] >= 9
+
+    class Merb::Rack::Application # :nodoc:
+      def call_with_sass(env)
+        if !Sass::Plugin.checked_for_updates ||
+            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+          Sass::Plugin.update_stylesheets
+        end
+
+        call_without_sass(env)
+      end
+      alias_method :call_without_sass, :call
+      alias_method :call, :call_with_sass
+    end
+
+  else
+
+    class MerbHandler # :nodoc:
+      def process_with_sass(request, response)
+        if !Sass::Plugin.checked_for_updates ||
+            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+          Sass::Plugin.update_stylesheets
+        end
+
+        process_without_sass(request, response)
+      end
+      alias_method :process_without_sass, :process
+      alias_method :process, :process_with_sass
+    end
+
+  end
+end

data/lib/sass/plugin/rails.rb

@@ -0,0 +1,24 @@
+unless defined?(Sass::RAILS_LOADED)
+  Sass::RAILS_LOADED = true
+
+  Sass::Plugin.options.merge!(:template_location  => RAILS_ROOT + '/public/stylesheets/sass',
+                              :css_location       => RAILS_ROOT + '/public/stylesheets',
+                              :always_check       => RAILS_ENV != "production",
+                              :full_exception     => RAILS_ENV != "production")
+
+  # :stopdoc:
+  module ActionController
+    class Base
+      alias_method :sass_old_process, :process
+      def process(*args)
+        if !Sass::Plugin.checked_for_updates ||
+            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+          Sass::Plugin.update_stylesheets
+        end
+
+        sass_old_process(*args)
+      end
+    end
+  end
+  # :startdoc:
+end

data/lib/sass/repl.rb

@@ -0,0 +1,44 @@
+require 'readline'
+
+module Sass
+  module Repl
+    class << self
+      def run
+        environment = Environment.new
+        environment.set_var('important', Script::String.new('!important'))
+        @line = 0
+        loop do
+          @line += 1
+          unless text = Readline.readline('>> ')
+            puts
+            return
+          end
+
+          Readline::HISTORY << text
+          parse_input(environment, text)
+        end
+      end
+
+      private
+
+      def parse_input(environment, text)
+        case text
+        when Script::MATCH
+          name = $1
+          guarded = $2 == '||='
+          val = Script::Parser.parse($3, @line, text.size - $3.size)
+
+          unless guarded && environment.var(name)
+            environment.set_var(name, val.perform(environment))
+          end
+
+          p environment.var(name)
+        else
+          p Script::Parser.parse(text, @line, 0).perform(environment)
+        end
+      rescue Sass::SyntaxError => e
+        puts "SyntaxError: #{e.message}"
+      end
+    end
+  end
+end

data/lib/sass/script.rb

@@ -0,0 +1,38 @@
+require 'strscan'
+require 'sass/script/variable'
+require 'sass/script/funcall'
+require 'sass/script/operation'
+require 'sass/script/literal'
+require 'sass/script/parser'
+
+module Sass
+  # This module contains various SassScript-related functionality.
+  module Script
+    # :stopdoc:
+    # The character that begins a variable.
+    VARIABLE_CHAR = ?!
+
+    # The regular expression used to parse variables
+    MATCH = /^!(\w+)\s*((?:\|\|)?=)\s*(.+)/
+
+    # The regular expression used to validate variables without matching
+    VALIDATE = /^!\w+$/
+
+    def self.resolve(value, line, offset, environment)
+      parse(value, line, offset).perform(environment).to_s
+    end
+
+    def self.parse(value, line, offset, filename = nil)
+      Parser.parse(value, line, offset, filename)
+    rescue Sass::SyntaxError => e
+      if e.message == "SassScript error"
+        e.instance_eval do
+          @message += ": #{value.dump}."
+        end
+      end
+      e.sass_line = line
+      raise e
+    end
+    # :startdoc:
+  end
+end

data/lib/sass/script/bool.rb

@@ -0,0 +1,13 @@
+require 'sass/script/literal'
+
+module Sass::Script
+  class Bool < Literal # :nodoc:
+    def to_s
+      @value.to_s
+    end
+
+    def to_bool
+      @value
+    end
+  end
+end