haml-edge 2.1.1

data/lib/sass/plugin.rb

@@ -0,0 +1,204 @@
+require 'sass/engine'
+
+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
+    extend 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)
+      exact_stylesheet_needs_update?(css_file, template_file)
+    end
+
+    def exact_stylesheet_needs_update?(css_file, template_file)
+      return true unless File.exists?(css_file)
+
+      css_mtime = File.mtime(css_file)
+      File.mtime(template_file) > css_mtime ||
+        dependencies(template_file).any?(&dependency_updated?(css_mtime))
+    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
+
+require 'sass/plugin/rails' if defined?(ActionController)
+require 'sass/plugin/merb'  if defined?(Merb::Plugins)

data/lib/sass/repl.rb

@@ -0,0 +1,51 @@
+require 'readline'
+
+module Sass
+  class Repl
+    def initialize(options = {})
+      @options = options
+    end
+
+    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}"
+      if @options[:trace]
+        e.backtrace.each do |e|
+          puts "\tfrom #{e}"
+        end
+      end
+    end
+  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

data/lib/sass/script/color.rb

@@ -0,0 +1,97 @@
+require 'sass/script/literal'
+
+module Sass::Script
+  class Color < Literal # :nodoc:
+    class << self; include Haml::Util; end
+
+    HTML4_COLORS = map_vals({
+        'black'   => 0x000000,
+        'silver'  => 0xc0c0c0,
+        'gray'    => 0x808080,
+        'white'   => 0xffffff,
+        'maroon'  => 0x800000,
+        'red'     => 0xff0000,
+        'purple'  => 0x800080,
+        'fuchsia' => 0xff00ff,
+        'green'   => 0x008000,
+        'lime'    => 0x00ff00,
+        'olive'   => 0x808000,
+        'yellow'  => 0xffff00,
+        'navy'    => 0x000080,
+        'blue'    => 0x0000ff,
+        'teal'    => 0x008080,
+        'aqua'    => 0x00ffff
+      }) {|color| (0..2).map {|n| color >> (n << 3) & 0xff}.reverse}
+    HTML4_COLORS_REVERSE = map_hash(HTML4_COLORS) {|k, v| [v, k]}
+
+    def initialize(rgb)
+      rgb = rgb.map {|c| c.to_i}
+      raise Sass::SyntaxError.new("Color values must be between 0 and 255") if rgb.any? {|c| c < 0 || c > 255}
+      super(rgb)
+    end
+
+    def plus(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :+)
+      else
+        super
+      end
+    end
+
+    def minus(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :-)
+      else
+        super
+      end
+    end
+
+    def times(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :*)
+      else
+        raise NoMethodError.new(nil, :times)
+      end
+    end
+
+    def div(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :/)
+      else
+        super
+      end
+    end
+
+    def mod(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :%)
+      else
+        raise NoMethodError.new(nil, :mod)
+      end
+    end
+
+    def to_s
+      return HTML4_COLORS_REVERSE[@value] if HTML4_COLORS_REVERSE[@value]
+      red, green, blue = @value.map { |num| num.to_s(16).rjust(2, '0') }
+      "##{red}#{green}#{blue}"
+    end
+    alias_method :inspect, :to_s
+
+    private
+
+    def piecewise(other, operation)
+      other_num = other.is_a? Number
+      other_val = other.value
+      if other_num && !other.unitless?
+        raise Sass::SyntaxError.new("Cannot add a number with units (#{other}) to a color (#{self}).") 
+      end
+
+      rgb = []
+      for i in (0...3)
+        res = @value[i].send(operation, other_num ? other_val : other_val[i])
+        rgb[i] = [ [res, 255].min, 0 ].max
+      end
+      Color.new(rgb)
+    end
+  end
+end

data/lib/sass/script/funcall.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'functions')
+module Sass
+  module Script
+    class Funcall # :nodoc:
+      attr_reader :name, :args
+
+      def initialize(name, args)
+        @name = name
+        @args = args
+      end
+
+      def inspect
+        "#{name}(#{args.map {|a| a.inspect}.join(', ')})"
+      end
+
+      def perform(environment)
+        args = self.args.map {|a| a.perform(environment)}
+        unless Haml::Util.has?(:public_instance_method, Functions, name) && name !~ /^__/
+          return Script::String.new("#{name}(#{args.map {|a| a.perform(environment)}.join(', ')})")
+        end
+
+        return Functions::EvaluationContext.new(environment.options).send(name, *args)
+      rescue ArgumentError => e
+        raise e unless e.backtrace.first =~ /:in `(#{name}|perform)'$/
+        raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
+      end
+    end
+  end
+end

data/lib/sass/script/functions.rb

@@ -0,0 +1,134 @@
+module Sass::Script
+  # Methods in this module are accessible from the Sass script context.
+  # For example, you can write
+  #
+  #   color = hsl(120, 100%, 50%)
+  #
+  # and it will call Sass::Script::Functions#hsl.
+  #
+  # You can add your own functions to this module,
+  # but there are a few things to keep in mind.
+  # First of all, the arguments passed are (currently undocumented) Sass::Script::Literal objects,
+  # Literal objects are also the expected return values.
+  #
+  # Second, making Ruby functions accessible from Sass introduces the temptation
+  # to do things like database access within stylesheets.
+  # This temptation must be resisted.
+  # Keep in mind that Sass stylesheets are only compiled once
+  # at a somewhat indeterminate time
+  # and then left as static CSS files.
+  # Any dynamic CSS should be left in <style> tags in the HTML.
+  #
+  # Within a sass function you can call the options method to gain access to the
+  # options hash that was used to create the Sass::Engine that is processing the function call.
+  #
+  # The following functions are provided:
+  # * +hsl+ - converts an <tt>hsl(hue, saturation, lightness)</tt> triplet into a color.
+  #
+  #   The +hue+ value should be between 0 and 360 inclusive,
+  #   saturation and lightness must be between <tt>0%</tt> to <tt>100%</tt> inclusive.
+  #   The percent sign is optional.
+  # * +percentage+ - converts a unitless number to a css percentage.
+  #
+  #   Example: <tt>percentage(14px / 7px) => 200%</tt>
+  # * +round+ - Rounds a number to the nearest whole number.
+  #
+  #   Example: <tt>round(10.4px) => 10px</tt>
+  # * +ceil+ - Rounds a number up to the nearest whole number.
+  #
+  #   Example: <tt>ceil(10.4px) => 11px</tt>
+  # * +floor+ - Rounds a number down to the nearest whole number.
+  #
+  #   Example: <tt>floor(10.6px) => 10px</tt>
+  # * +abs+ - Returns the absolute value of a number.
+  #
+  #   Example: <tt>abs(-10px) => 10px</tt>
+  module Functions
+    class EvaluationContext # :nodoc:
+      include Sass::Script::Functions
+
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+    end
+
+    instance_methods.each { |m| undef_method m unless m.to_s =~ /^__/ }
+
+    # Creates a Sass::Script::Color object from hue, saturation, and lightness.
+    # As per the CSS3 spec (http://www.w3.org/TR/css3-color/#hsl-color),
+    # hue is in degrees,
+    # and saturation and lightness are percentages.
+    def hsl(h, s, l)
+      original_s = s
+      original_l = l
+      # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
+      h, s, l = [h, s, l].map { |a| a.value }
+      raise ArgumentError.new("Saturation #{s} must be between 0% and 100%") if s < 0 || s > 100
+      raise ArgumentError.new("Lightness #{l} must be between 0% and 100%") if l < 0 || l > 100
+
+      h = (h % 360) / 360.0
+      s /= 100.0
+      l /= 100.0
+
+      m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s
+      m1 = l * 2 - m2
+      Color.new([hue_to_rgb(m1, m2, h + 1.0/3),
+                 hue_to_rgb(m1, m2, h),
+                 hue_to_rgb(m1, m2, h - 1.0/3)].map { |c| (c * 0xff).round })
+    end
+
+    # Converts a unitless number into a percent and multiplies the number by 100.
+    # E.g. percentage(100px / 50px) => 200%
+    # Some may find this more natural than: 100% * 100px / 50px
+    def percentage(value)
+      unless value.is_a?(Sass::Script::Number) && value.unitless?
+        raise ArgumentError.new("#{value} is not a unitless number")
+      end
+      Sass::Script::Number.new(value.value * 100, ['%'])
+    end
+
+    # Rounds a number to the nearest whole number.
+    def round(value)
+      numeric_transformation(value) {|n| n.round}
+    end
+
+    # Rounds up to the nearest whole number.
+    def ceil(value)
+      numeric_transformation(value) {|n| n.ceil}
+    end
+
+    # Rounds down to the nearest whole number.
+    def floor(value)
+      numeric_transformation(value) {|n| n.floor}
+    end
+
+    # Returns the absolute value of a number.
+    def abs(value)
+      numeric_transformation(value) {|n| n.abs}
+    end
+
+    private
+
+    # This method implements the pattern of transforming a numeric value into
+    # another numeric value with the same units.
+    # It yields a number to a block to perform the operation and return a number
+    def numeric_transformation(value)
+      unless value.is_a?(Sass::Script::Number)
+        calling_function = caller.first.scan(/`([^']+)'/).first.first
+        raise Sass::SyntaxError.new("#{value} is not a number for `#{calling_function}'")
+      end
+      Sass::Script::Number.new(yield(value.value), value.numerator_units, value.denominator_units)
+    end
+
+    def hue_to_rgb(m1, m2, h)
+      h += 1 if h < 0
+      h -= 1 if h > 1
+      return m1 + (m2 - m1) * h * 6 if h * 6 < 1
+      return m2 if h * 2 < 1
+      return m1 + (m2 - m1) * (2.0/3 - h) * 6 if h * 3 < 2
+      return m1
+    end
+  end
+end

data/lib/sass/script/lexer.rb

@@ -0,0 +1,148 @@
+require 'strscan'
+
+module Sass
+  module Script
+    class Lexer # :nodoc:
+      Token = Struct.new(:type, :value, :line, :offset)
+
+      OPERATORS = {
+        '+' => :plus,
+        '-' => :minus,
+        '*' => :times,
+        '/' => :div,
+        '%' => :mod,
+        '(' => :lparen,
+        ')' => :rparen,
+        ',' => :comma,
+        'and' => :and,
+        'or' => :or,
+        'not' => :not,
+        '==' => :eq,
+        '!=' => :neq,
+        '>=' => :gte,
+        '<=' => :lte,
+        '>' => :gt,
+        '<' => :lt,
+        '#{' => :begin_interpolation,
+        '}' => :end_interpolation,
+      }
+
+      # We'll want to match longer names first
+      # so that > and < don't clobber >= and <=
+      OP_NAMES = OPERATORS.keys.sort_by {|o| -o.size}
+
+      REGULAR_EXPRESSIONS = {
+        :whitespace => /\s*/,
+        :variable => /!(\w+)/,
+        :ident => /(\\.|\#\{|[^\s\\+\-*\/%(),=!])+/,
+        :string_end => /((?:\\.|\#[^{]|[^"\\#])*)(?:"|(?=#\{))/,
+        :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
+        :color => /\##{"([0-9a-fA-F]{1,2})" * 3}|(#{Color::HTML4_COLORS.keys.join("|")})/,
+        :bool => /(true|false)\b/,
+        :op => %r{(#{Regexp.union(*OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + (s =~ /\w$/ ? '(?:\b|$)' : ''))})})}
+      }
+
+      def initialize(str, line, offset)
+        @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
+        @line = line
+        @offset = offset
+        @prev = nil
+      end
+
+      def next
+        @tok ||= read_token
+        @tok, tok = nil, @tok
+        @prev = tok
+        return tok
+      end
+
+      def peek
+        @tok ||= read_token
+      end
+
+      def done?
+        whitespace unless after_interpolation?
+        @scanner.eos? && @tok.nil?
+      end
+
+      private
+
+      def read_token
+        return if done?
+
+        value = token
+        unless value
+          raise SyntaxError.new("Syntax error in '#{@scanner.string}' at character #{current_position}.")
+        end
+        Token.new(value.first, value.last, @line, last_match_position)
+      end
+
+      def whitespace
+        @scanner.scan(REGULAR_EXPRESSIONS[:whitespace])
+      end
+
+      def token
+        return string('') if after_interpolation?
+        variable || string || number || color || bool || op || ident
+      end
+
+      def variable
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:variable])
+        [:const, @scanner[1]]
+      end
+
+      def ident
+        return unless s = @scanner.scan(REGULAR_EXPRESSIONS[:ident])
+        [:ident, s.gsub(/\\(.)/, '\1')]
+      end
+
+      def string(start_char = '"')
+        return unless @scanner.scan(/#{start_char}#{REGULAR_EXPRESSIONS[:string_end]}/)
+        [:string, Script::String.new(@scanner[1].gsub(/\\([^0-9a-f])/, '\1').gsub(/\\([0-9a-f]{1,4})/, "\\\\\\1"))]
+      end
+
+      def begin_interpolation
+        @scanner.scan
+      end
+
+      def number
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:number])
+        value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
+        value = -value if @scanner[1]
+        [:number, Script::Number.new(value, Array(@scanner[4]))]
+      end
+
+      def color
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:color])
+        value = if @scanner[4]
+                  color = Color::HTML4_COLORS[@scanner[4].downcase]
+                else
+                  (1..3).map {|i| @scanner[i]}.map {|num| num.ljust(2, num).to_i(16)}
+                end
+        [:color, Script::Color.new(value)]
+      end
+
+      def bool
+        return unless s = @scanner.scan(REGULAR_EXPRESSIONS[:bool])
+        [:bool, Script::Bool.new(s == 'true')]
+      end
+
+      def op
+        return unless op = @scanner.scan(REGULAR_EXPRESSIONS[:op])
+        [OPERATORS[op]]
+      end
+
+      def current_position
+        @offset + @scanner.pos + 1
+      end
+
+      def last_match_position
+        current_position - @scanner.matched_size
+      end
+
+      def after_interpolation?
+        @prev && @prev.type == :end_interpolation
+      end
+    end
+  end
+end