compass-core 1.0.0.alpha.13

data/lib/compass/core/sass_extensions/functions/image_size.rb

@@ -0,0 +1,117 @@
+module Compass::Core::SassExtensions::Functions::ImageSize
+  KNOWN_TYPES = %w(png gif jpg jpeg)
+
+  # Returns the width of the image relative to the images directory
+  def image_width(image_file)
+    width, _ = image_dimensions(image_file)
+    Sass::Script::Number.new(width,["px"])
+  end
+  
+  # Returns the height of the image relative to the images directory
+  def image_height(image_file)
+    _, height = image_dimensions(image_file)
+    Sass::Script::Number.new(height, ["px"])
+  end
+
+  class ImageProperties
+    def initialize(file)
+      @file = (file.respond_to?(:to_path) ? file.to_path : file)
+      @file_type = File.extname(@file)[1..-1].downcase
+      unless KNOWN_TYPES.include?(@file_type)
+        raise Sass::SyntaxError, "Unrecognized file type: #{@file_type}"
+      end
+    end
+
+    def size
+      @dimensions ||= send(:"get_size_for_#{@file_type}")
+    end
+
+  private
+    def get_size_for_png
+      File.open(@file, "rb") {|io| io.read}[0x10..0x18].unpack('NN')
+    end
+
+    def get_size_for_gif
+      File.open(@file, "rb") {|io| io.read}[6..10].unpack('SS')
+    end
+
+    def get_size_for_jpg
+      get_size_for_jpeg
+    end
+
+    def get_size_for_jpeg
+      jpeg = JPEG.new(@file)
+      [jpeg.width, jpeg.height]
+    end
+  end
+
+private
+
+  def image_dimensions(image_file)
+    image_file = image_file.respond_to?(:value) ? image_file.value : image_file
+    options[:compass] ||= {}
+    options[:compass][:image_dimensions] ||= {}
+    options[:compass][:image_dimensions][image_file] = ImageProperties.new(image_path_for_size(image_file)).size
+  end
+  
+  def image_path_for_size(image_file)
+    if File.exists?(image_file)
+      return image_file 
+    end
+    real_path(image_file)
+  end
+
+  def real_path(image_file)
+    # Compute the real path to the image on the file stystem if the images_dir is set.
+    if Compass.configuration.images_path
+      File.join(Compass.configuration.images_path, image_file)
+    else
+      File.join(Compass.configuration.project_path, image_file)
+    end
+  end
+
+  class JPEG
+    attr_reader :width, :height, :bits
+
+    def initialize(file)
+      if file.kind_of? IO
+        examine(file)
+      else
+        File.open(file, 'rb') { |io| examine(io) }
+      end
+    end
+
+  private
+    def examine(io)
+      class << io
+        unless method_defined?(:readbyte)
+          def readbyte
+            getc
+          end
+        end
+        def readint; (readbyte << 8) + readbyte; end
+        def readframe; read(readint - 2); end
+        def readsof; [readint, readbyte, readint, readint, readbyte]; end
+        def next
+          c = readbyte while c != 0xFF
+          c = readbyte while c == 0xFF
+          c
+        end
+      end
+
+      raise 'malformed JPEG!' unless io.readbyte == 0xFF && io.readbyte == 0xD8 # SOI
+
+      while marker = io.next
+        case marker
+          when 0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF # SOF markers
+            length, @bits, @height, @width, components = io.readsof
+            raise 'malformed JPEG' unless length == 8 + components * 3
+          when 0xD9, 0xDA then  break # EOI, SOS
+          when 0xFE then @comment = io.readframe # COM
+          when 0xE1 then io.readframe # APP1, contains EXIF tag
+          else io.readframe # ignore frame
+        end
+      end
+    end
+end
+end

data/lib/compass/core/sass_extensions/functions/inline_image.rb

@@ -0,0 +1,64 @@
+module Compass::Core::SassExtensions::Functions::InlineImage
+
+  def inline_image(path, mime_type = nil)
+    path = path.value
+    real_path = File.join(Compass.configuration.images_path, path)
+    inline_image_string(data(real_path), compute_mime_type(path, mime_type))
+  end
+
+  def inline_font_files(*args)
+    raise Sass::SyntaxError, "An even number of arguments must be passed to font_files()" unless args.size % 2 == 0
+    files = []
+    while args.size > 0
+      path = args.shift.value
+      real_path = File.join(Compass.configuration.fonts_path, path)
+      url = inline_image_string(data(real_path), compute_mime_type(path))
+      files << "#{url} format('#{args.shift}')"
+    end
+    Sass::Script::String.new(files.join(", "))
+  end
+
+protected
+  def inline_image_string(data, mime_type)
+    data = [data].flatten.pack('m').gsub("\n","")
+    url = "url('data:#{mime_type};base64,#{data}')"
+    Sass::Script::String.new(url)
+  end
+
+private
+  def compute_mime_type(path, mime_type = nil)
+    return mime_type if mime_type
+    case path
+    when /\.png$/i
+      'image/png'
+    when /\.jpe?g$/i
+      'image/jpeg'
+    when /\.gif$/i
+      'image/gif'
+    when /\.svg$/i
+      'image/svg+xml'
+    when /\.otf$/i
+      'font/opentype'
+    when /\.eot$/i
+      'application/vnd.ms-fontobject'
+    when /\.ttf$/i
+      'font/truetype'
+    when /\.woff$/i
+      'application/x-font-woff'
+    when /\.off$/i
+      'font/openfont'
+    when /\.([a-zA-Z]+)$/
+      "image/#{Regexp.last_match(1).downcase}"
+    else
+      raise Compass::Error, "A mime type could not be determined for #{path}, please specify one explicitly."
+    end
+  end
+
+  def data(real_path)
+    if File.readable?(real_path)
+      File.open(real_path, "rb") {|io| io.read}
+    else
+      raise Compass::Error, "File not found or cannot be read: #{real_path}"
+    end
+  end
+end

data/lib/compass/core/sass_extensions/functions/lists.rb

@@ -0,0 +1,101 @@
+module Compass::Core::SassExtensions::Functions::Lists
+
+  # Returns true when the object is false, an empty string, or an empty list
+  def blank(obj)
+    case obj
+    when Sass::Script::Bool
+      Sass::Script::Bool.new !obj.to_bool
+    when Sass::Script::String
+      Sass::Script::Bool.new obj.value.strip.size == 0
+    when Sass::Script::List
+      Sass::Script::Bool.new obj.value.size == 0 || obj.value.all?{|el| blank(el).to_bool}
+    else
+      Sass::Script::Bool.new false
+    end
+  end
+
+  # Returns a new list after removing any non-true values
+  def compact(*args)
+    sep = :comma
+    if args.size == 1 && args.first.is_a?(Sass::Script::List)
+      list = args.first
+      args = list.value
+      sep = list.separator
+    end
+    Sass::Script::List.new(args.reject{|a| !a.to_bool}, sep)
+  end
+
+  # Get the nth value from a list
+  def _compass_nth(list, place)
+    assert_type list, :List
+    if place.value == "first"
+      list.value.first
+    elsif place.value == "last"
+      list.value.last
+    else
+      list.value[place.value - 1]
+    end
+  end
+
+  # Returns a list object from a value that was passed.
+  # This can be used to unpack a space separated list that got turned
+  # into a string by sass before it was passed to a mixin.
+  def _compass_list(arg)
+    if arg.is_a?(Sass::Script::List)
+      Sass::Script::List.new(arg.value.dup, arg.separator)
+    else
+      Sass::Script::List.new([arg], :space)
+    end
+  end
+
+  # If the argument is a list, it will return a new list that is space delimited
+  # Otherwise it returns a new, single element, space-delimited list.
+  def _compass_space_list(list)
+    if list.is_a?(Sass::Script::List)
+      Sass::Script::List.new(list.value.dup, :space)
+    else
+      Sass::Script::List.new([list], :space)
+    end
+  end
+
+  # Returns the size of the list.
+  def _compass_list_size(list)
+    assert_list list
+    Sass::Script::Number.new(list.value.size)
+  end
+
+  # slice a sublist from a list
+  def _compass_slice(list, start_index, end_index = nil)
+    end_index ||= Sass::Script::Number.new(-1)
+    start_index = start_index.value
+    end_index = end_index.value
+    start_index -= 1 unless start_index < 0
+    end_index -= 1 unless end_index < 0
+    Sass::Script::List.new list.values[start_index..end_index], list.separator
+  end
+
+  # removes the given values from the list.
+  def reject(list, *values)
+    Sass::Script::List.new(list.value.reject{|v| values.any?{|o| v == o}}, list.separator)
+  end
+
+  # returns the first value of a space delimited list.
+  def first_value_of(list)
+    if list.is_a?(Sass::Script::String)
+      Sass::Script::String.new(list.value.split(/\s+/).first)
+    elsif defined?(Sass::Script::List) && list.is_a?(Sass::Script::List)
+      list.value.first
+    else
+      list
+    end
+  end
+
+  protected
+
+  def assert_list(value)
+    unless value.is_a?(Sass::Script::List)
+      raise ArgumentError.new("#{value.inspect} is not a list")
+    end
+  end
+
+end

data/lib/compass/core/sass_extensions/functions/math.rb

@@ -0,0 +1,92 @@
+module Compass::Core::SassExtensions::Functions::Math
+  extend Compass::Core::SassExtensions::Functions::SassDeclarationHelper
+
+  PI = Sass::Script::Number.new(Math::PI)
+  def pi()
+    PI
+  end
+  declare :pi, []
+
+  def random(*args)
+    value = if args.length == 1
+      rand(args.pop.value)
+    else
+      range = (args.first.value..args.last.value).to_a
+      range[rand(range.length)]
+    end
+    Sass::Script::Number.new(value)
+  end
+  declare :random, [:limit]
+  declare :random, [:start, :limit]
+
+  def sin(number)
+    trig(:sin, number)
+  end
+  declare :sin, [:number]
+
+  def asin(number)
+    trig(:asin, number)
+  end
+  declare :asin, [:number]
+
+  def cos(number)
+    trig(:cos, number)
+  end
+  declare :cos, [:number]
+
+  def acos(number)
+    trig(:acos, number)
+  end
+  declare :acos, [:number]
+
+  def tan(number)
+    trig(:tan, number)
+  end
+  declare :tan, [:number]
+
+  def atan(number)
+    trig(:atan, number)
+  end
+  declare :atan, [:number]
+
+  def e
+    Sass::Script::Number.new(Math::E)
+  end
+  declare :e, []
+
+  def logarithm(number, base = e )
+    assert_type number, :Number
+    assert_type base, :Number
+    raise Sass::SyntaxError, "base to logarithm must be unitless." unless base.unitless?
+
+    result = Math.log(number.value, base.value) rescue Math.log(number.value) / Math.log(base.value)
+    Sass::Script::Number.new(result, number.numerator_units, number.denominator_units)
+  end
+  declare :logarithm, [:number]
+  declare :logarithm, [:number, :base]
+
+  def sqrt(number)
+    numeric_transformation(number) { |n| Math.sqrt(n) }
+  end
+  declare :sqrt, [:number]
+
+  alias square_root sqrt
+  declare :square_root, [:number]
+
+  def pow(number, exponent)
+    assert_type number, :Number
+    assert_type exponent, :Number
+    raise Sass::SyntaxError, "exponent to pow must be unitless." unless exponent.unitless?
+    Sass::Script::Number.new(number.value**exponent.value, number.numerator_units, number.denominator_units)
+  end
+  declare :pow, [:number, :exponent]
+
+  private
+  def trig(operation, number)
+    if number.numerator_units == ["deg"] && number.denominator_units == []
+      Sass::Script::Number.new(Math.send(operation, Math::PI * number.value / 180))
+    else
+      Sass::Script::Number.new(Math.send(operation, number.value), number.numerator_units, number.denominator_units)
+    end
+  end
+end

data/lib/compass/core/sass_extensions/functions/selectors.rb

@@ -0,0 +1,64 @@
+module Compass::Core::SassExtensions::Functions::Selectors
+  COMMA_SEPARATOR = /\s*,\s*/
+
+  # Permute multiple selectors each of which may be comma delimited, the end result is
+  # a new selector that is the equivalent of nesting each under the previous selector.
+  # To illustrate, the following mixins are equivalent:
+  # =mixin-a(!selector1, !selector2, !selector3)
+  #   #{!selector1}
+  #     #{selector2}
+  #       #{selector3}
+  #         width: 2px
+  # =mixin-b(!selector1, !selector2)
+  #   #{nest(!selector, !selector2, !selector3)}
+  #     width: 2px
+  def nest(*arguments)
+    nested = arguments.map{|a| a.value}.inject do |memo,arg|
+      ancestors = memo.split(COMMA_SEPARATOR)
+      descendants = arg.split(COMMA_SEPARATOR)
+      ancestors.map{|a| descendants.map{|d| "#{a} #{d}"}.join(", ")}.join(", ")
+    end
+    Sass::Script::String.new(nested)
+  end
+
+  # Permute two selectors, the first may be comma delimited.
+  # The end result is a new selector that is the equivalent of nesting the second
+  # selector under the first one in a sass file and preceding it with an &.
+  # To illustrate, the following mixins are equivalent:
+  # =mixin-a(!selector, !to_append)
+  #   #{!selector}
+  #     &#{!to_append}
+  #       width: 2px
+  # =mixin-b(!selector, !to_append)
+  #   #{append_selector(!selector, !to_append)}
+  #     width: 2px
+  def append_selector(selector, to_append)
+    ancestors = selector.value.split(COMMA_SEPARATOR)
+    descendants = to_append.value.split(COMMA_SEPARATOR)
+    nested = ancestors.map{|a| descendants.map{|d| "#{a}#{d}"}.join(", ")}.join(", ")
+    Sass::Script::String.new(nested)
+  end
+
+  # Return the header selectors for the levels indicated
+  # Defaults to all headers h1 through h6
+  # For example:
+  # headers(all) => h1, h2, h3, h4, h5, h6
+  # headers(4) => h1, h2, h3, h4
+  # headers(2,4) => h2, h3, h4
+  def headers(from = nil, to = nil)
+    if from && !to
+      if from.is_a?(Sass::Script::String) && from.value == "all"
+        from = Sass::Script::Number.new(1)
+        to = Sass::Script::Number.new(6)
+      else
+        to = from
+        from = Sass::Script::Number.new(1)
+      end
+    else
+      from ||= Sass::Script::Number.new(1)
+      to ||= Sass::Script::Number.new(6)
+    end
+    Sass::Script::String.new((from.value..to.value).map{|n| "h#{n}"}.join(", "))
+  end
+  alias headings headers
+end

data/lib/compass/core/sass_extensions/functions/urls.rb

@@ -0,0 +1,297 @@
+module Compass::Core::SassExtensions::Functions::Urls
+
+
+  def self.has?(base, instance_method)
+    Sass::Util.has?(:instance_method, base, instance_method)
+  end
+
+  def self.included(base)
+    base.send(:include, StylesheetUrl) unless has?(base, :stylesheet_url)
+    base.send(:include, FontUrl) unless has?(base, :font_url)
+    base.send(:include, ImageUrl) unless has?(base, :image_url)
+    base.send(:include, GeneratedImageUrl) unless has?(base, :generated_image_url)
+  end
+
+  module StylesheetUrl
+    def self.included(base)
+      if base.respond_to?(:declare)
+        base.declare :stylesheet_url, [:path]
+        base.declare :stylesheet_url, [:path, :only_path]
+      end
+    end
+    def stylesheet_url(path, only_path = Sass::Script::Bool.new(false))
+      # Compute the path to the stylesheet, either root relative or stylesheet relative
+      # or nil if the http_images_path is not set in the configuration.
+      http_stylesheets_path = if relative?
+        compute_relative_path(Compass.configuration.css_path)
+      elsif Compass.configuration.http_stylesheets_path
+        Compass.configuration.http_stylesheets_path
+      else
+        Compass.configuration.http_root_relative(Compass.configuration.css_dir)
+      end
+
+      path = "#{http_stylesheets_path}/#{path.value}"
+      if only_path.to_bool
+        Sass::Script::String.new(clean_path(path))
+      else
+        clean_url(path)
+      end
+    end
+  end
+
+  module FontUrl
+    def self.included(base)
+      if base.respond_to?(:declare)
+        base.declare :font_url,       [:path]
+        base.declare :font_url,       [:path, :only_path]
+        base.declare :font_url,       [:path, :only_path, :cache_buster]
+      end
+    end
+    def font_url(path, only_path = Sass::Script::Bool.new(false), cache_buster = Sass::Script::Bool.new(false))
+      path = path.value # get to the string value of the literal.
+
+      # Short curcuit if they have provided an absolute url.
+      if absolute_path?(path)
+        return Sass::Script::String.new("url(#{path})")
+      end
+
+      # Compute the path to the font file, either root relative or stylesheet relative
+      # or nil if the http_fonts_path cannot be determined from the configuration.
+      http_fonts_path = if relative?
+                          compute_relative_path(Compass.configuration.fonts_path)
+                        else
+                          Compass.configuration.http_fonts_path
+                        end
+
+      # Compute the real path to the font on the file system if the fonts_dir is set.
+      real_path = if Compass.configuration.fonts_dir
+        File.join(Compass.configuration.project_path, Compass.configuration.fonts_dir, path)
+      end
+
+      # prepend the path to the font if there's one
+      if http_fonts_path
+        http_fonts_path = "#{http_fonts_path}/" unless http_fonts_path[-1..-1] == "/"
+        path = "#{http_fonts_path}#{path}"
+      end
+
+      # Compute the asset host unless in relative mode.
+      asset_host = if !relative? && Compass.configuration.asset_host
+        Compass.configuration.asset_host.call(path)
+      end
+
+      # Compute and append the cache buster if there is one.
+      if cache_buster.to_bool
+        if cache_buster.is_a?(Sass::Script::String)
+          path += "?#{cache_buster.value}"
+        else
+          path = cache_busted_path(path, real_path)
+        end
+      end
+
+      # prepend the asset host if there is one.
+      path = "#{asset_host}#{'/' unless path[0..0] == "/"}#{path}" if asset_host
+
+      if only_path.to_bool
+        Sass::Script::String.new(clean_path(path))
+      else
+        clean_url(path)
+      end
+    end
+  end
+
+  module ImageUrl
+    def self.included(base)
+      if base.respond_to?(:declare)
+        base.declare :image_url,      [:path]
+        base.declare :image_url,      [:path, :only_path]
+        base.declare :image_url,      [:path, :only_path, :cache_buster]
+      end
+    end
+    def image_url(path, only_path = Sass::Script::Bool.new(false), cache_buster = Sass::Script::Bool.new(true))
+      path = path.value # get to the string value of the literal.
+
+      if path =~ %r{^#{Regexp.escape(Compass.configuration.http_images_path)}/(.*)}
+        # Treat root relative urls (without a protocol) like normal if they start with
+        # the images path.
+        path = $1
+      elsif absolute_path?(path)
+        # Short curcuit if they have provided an absolute url.
+        return Sass::Script::String.new("url(#{path})")
+      end
+
+      # Compute the path to the image, either root relative or stylesheet relative
+      # or nil if the http_images_path is not set in the configuration.
+      http_images_path = if relative?
+        compute_relative_path(Compass.configuration.images_path)
+      elsif Compass.configuration.http_images_path
+        Compass.configuration.http_images_path
+      else
+        Compass.configuration.http_root_relative(Compass.configuration.images_dir)
+      end
+
+      # Compute the real path to the image on the file stystem if the images_dir is set.
+      real_path = if Compass.configuration.images_path
+        File.join(Compass.configuration.images_path, path)
+      else
+        File.join(Compass.configuration.project_path, path)
+      end
+
+      # prepend the path to the image if there's one
+      if http_images_path
+        http_images_path = "#{http_images_path}/" unless http_images_path[-1..-1] == "/"
+        path = "#{http_images_path}#{path}"
+      end
+
+      # Compute the asset host unless in relative mode.
+      asset_host = if !relative? && Compass.configuration.asset_host
+        Compass.configuration.asset_host.call(path)
+      end
+
+      # Compute and append the cache buster if there is one.
+      if cache_buster.to_bool
+        if cache_buster.is_a?(Sass::Script::String)
+          path += "?#{cache_buster.value}"
+        else
+          path = cache_busted_path(path, real_path)
+        end
+      end
+
+      # prepend the asset host if there is one.
+      path = "#{asset_host}#{'/' unless path[0..0] == "/"}#{path}" if asset_host
+
+      if only_path.to_bool
+        Sass::Script::String.new(clean_path(path))
+      else
+        clean_url(path)
+      end
+    end
+  end
+
+  module GeneratedImageUrl
+    def self.included(base)
+      if base.respond_to?(:declare)
+        base.declare :generated_image_url, [:path]
+        base.declare :generated_image_url, [:path, :cache_buster]
+      end
+    end
+    def generated_image_url(path, cache_buster = Sass::Script::Bool.new(false))
+      path = path.value # get to the string value of the literal.
+
+      if path =~ %r{^#{Regexp.escape(Compass.configuration.http_generated_images_path)}/(.*)}
+        # Treat root relative urls (without a protocol) like normal if they start with
+        # the generated_images path.
+        path = $1
+      elsif absolute_path?(path)
+        # Short curcuit if they have provided an absolute url.
+        return Sass::Script::String.new("url(#{path})")
+      end
+
+      # Compute the path to the image, either root relative or stylesheet relative
+      # or nil if the http_generated_images_path is not set in the configuration.
+      http_generated_images_path = if relative?
+        compute_relative_path(Compass.configuration.generated_images_path)
+      elsif Compass.configuration.http_generated_images_path
+        Compass.configuration.http_generated_images_path
+      else
+        Compass.configuration.http_root_relative(Compass.configuration.generated_images_dir)
+      end
+
+      # Compute the real path to the image on the file stystem if the generated_images_dir is set.
+      real_path = if Compass.configuration.images_path
+        File.join(Compass.configuration.images_path, path)
+      else
+        File.join(Compass.configuration.project_path, path)
+      end
+
+      # prepend the path to the image if there's one
+      if http_generated_images_path
+        http_generated_images_path = "#{http_generated_images_path}/" unless http_generated_images_path[-1..-1] == "/"
+        path = "#{http_generated_images_path}#{path}"
+      end
+
+      # Compute the asset host unless in relative mode.
+      asset_host = if !relative? && Compass.configuration.asset_host
+        Compass.configuration.asset_host.call(path)
+      end
+
+      # Compute and append the cache buster if there is one.
+      if cache_buster.to_bool
+        if cache_buster.is_a?(Sass::Script::String)
+          path += "?#{cache_buster.value}"
+        else
+          path = cache_busted_path(path, real_path)
+        end
+      end
+
+      # prepend the asset host if there is one.
+      path = "#{asset_host}#{'/' unless path[0..0] == "/"}#{path}" if asset_host
+
+      clean_url(path)
+    end
+  end
+
+  private
+
+  # Emits a path, taking off any leading "./"
+  def clean_path(url)
+    url = url.to_s
+    url = url[0..1] == "./" ? url[2..-1] : url
+  end
+
+  # Emits a url, taking off any leading "./"
+  def clean_url(url)
+    Sass::Script::String.new("url('#{clean_path(url)}')")
+  end
+
+  def relative?
+    Compass.configuration.relative_assets?
+  end
+
+  def absolute_path?(path)
+    path[0..0] == "/" || path[0..3] == "http"
+  end
+
+  def compute_relative_path(path)
+    if (target_css_file = options[:css_filename])
+      Pathname.new(path).relative_path_from(Pathname.new(File.dirname(target_css_file))).to_s
+    end
+  end
+
+  def cache_busted_path(path, real_path)
+    cache_buster = compute_cache_buster(path, real_path)
+    if cache_buster.nil?
+      return path
+    elsif cache_buster.is_a?(String)
+      cache_buster = {:query => cache_buster}
+    else
+      path = cache_buster[:path] if cache_buster[:path]
+    end
+    
+    if cache_buster[:query]
+      "%s?%s" % [path, cache_buster[:query]]
+    else
+      path
+    end
+  end
+
+  def compute_cache_buster(path, real_path)
+    if Compass.configuration.asset_cache_buster
+      args = [path]
+      if Compass.configuration.asset_cache_buster.arity > 1
+        args << (File.new(real_path) if real_path)
+      end
+      Compass.configuration.asset_cache_buster.call(*args)
+    elsif real_path
+      default_cache_buster(path, real_path)
+    end
+  end
+
+  def default_cache_buster(path, real_path)
+    if File.readable?(real_path)
+      File.mtime(real_path).to_i.to_s
+    else
+      $stderr.puts "WARNING: '#{File.basename(path)}' was not found (or cannot be read) in #{File.dirname(real_path)}"
+    end
+  end
+
+end