compass 0.13.alpha.12 → 1.0.0.alpha.13

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

@@ -1,114 +0,0 @@
-module Compass::SassExtensions::Functions::ImageSize
-  # 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]
-    end
-
-    def size
-      @dimensions ||= send(:"get_size_for_#{@file_type}")
-    rescue NoMethodError
-      raise Sass::SyntaxError, "Unrecognized file type: #{@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/sass_extensions/functions/inline_image.rb

@@ -1,64 +0,0 @@
-module Compass::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/sass_extensions/functions/lists.rb

@@ -1,101 +0,0 @@
-module Compass::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/sass_extensions/functions/math.rb

@@ -1,93 +0,0 @@
-module Compass::SassExtensions::Functions::Math
-
-  extend Compass::SassExtensions::Functions::SassDeclarationHelper
-
-  PI = Sass::Script::Number.new(Math::PI)
-  def pi()
-    PI
-  end
-  register_sass_function :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
-  register_sass_function :random, [:limit]
-  register_sass_function :random, [:start, :limit]
-
-  def sin(number)
-    trig(:sin, number)
-  end
-  register_sass_function :sin, [:number]
-
-  def asin(number)
-    trig(:asin, number)
-  end
-  register_sass_function :asin, [:number]
-
-  def cos(number)
-    trig(:cos, number)
-  end
-  register_sass_function :cos, [:number]
-
-  def acos(number)
-    trig(:acos, number)
-  end
-  register_sass_function :acos, [:number]
-
-  def tan(number)
-    trig(:tan, number)
-  end
-  register_sass_function :tan, [:number]
-
-  def atan(number)
-    trig(:atan, number)
-  end
-  register_sass_function :atan, [:number]
-
-  def e
-    Sass::Script::Number.new(Math::E)
-  end
-  register_sass_function :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
-  register_sass_function :logarithm, [:number]
-  register_sass_function :logarithm, [:number, :base]
-
-  def sqrt(number)
-    numeric_transformation(number) { |n| Math.sqrt(n) }
-  end
-  register_sass_function :sqrt, [:number]
-
-  alias square_root sqrt
-  register_sass_function :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
-  register_sass_function :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/sass_extensions/functions/selectors.rb

@@ -1,64 +0,0 @@
-module Compass::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/sass_extensions/functions/urls.rb

@@ -1,297 +0,0 @@
-module Compass::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