compass-core 1.0.0.alpha.13

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

@@ -0,0 +1,162 @@
+require 'pathname'
+module Compass::Core::SassExtensions::Functions::Configuration
+  extend Compass::Core::SassExtensions::Functions::SassDeclarationHelper
+
+  # Users who need to support windows and unix paths in their configuration
+  # should construct them with this helper function.
+  def join_file_segments(*segments)
+    quoted_string(File.join(*segments.map{|s| assert_type s, :String; s.value}))
+  end
+  declare :absolute_path, [], :var_args => true
+
+  # Returns an absolute path for the path relative to the sass file it was called from.
+  def absolute_path(relative_path)
+    quoted_string(File.expand_path(File.join(File.dirname(options[:filename]), relative_path.value)))
+  end
+  declare :absolute_path, [:relative_path]
+
+  # split a file into directory, basename, and extension
+  def split_filename(path)
+    pathname = Pathname.new(path.value)
+    list(quoted_string(pathname.dirname.to_s),
+         quoted_string(pathname.basename(pathname.extname).to_s),
+         quoted_string(pathname.extname.to_s),
+         :space)
+  end
+  declare :split_filename, [:path]
+
+  # Returns true if the compass compiler is compiling this stylesheet.
+  def using_compass_compiler
+    bool(options[:compass] && options[:compass][:compiler_in_use])
+  end
+  declare :using_compass_compiler, []
+
+  def reset_configuration()
+    Compass.reset_configuration!
+    null()
+  end
+  declare :reset_configuration, []
+
+  def add_sass_configuration(project_path)
+    css_location = File.expand_path(options[:css_location]) if options[:css_location]
+    template_location = File.expand_path(options[:template_location]) if options[:template_location]
+    original_filename = File.expand_path(options[:original_filename]) if options[:original_filename]
+    project_path = if project_path.value.nil?
+                     if css_location && template_location
+                       common_parent_directory(css_location, template_location)
+                     end
+                   else
+                     project_path.value
+                   end
+    config = {
+      :project_path => project_path,
+      :cache => options[:cache],
+      :additional_import_paths => options[:load_paths],
+      :line_comments => options[:line_comments]
+    }
+    unless options[:quiet].nil?
+      config.update(:disable_warnings => options[:quiet])
+    end
+    if project_path && css_location && (css_dir = relative_path_from(css_location, project_path))
+      config.update(:css_dir => css_dir)
+    elsif css_location
+      config.update(:css_path => css_location)
+    end
+    if project_path && template_location && (sass_dir = relative_path_from(template_location, project_path))
+      config.update(:sass_dir => sass_dir)
+    elsif template_location
+      config.update(:css_path => template_location)
+    end
+    config_name = "Sass Defaults: #{project_path ? relative_path_from(original_filename, project_path) : original_filename}"
+    Compass.add_configuration(Compass::Configuration::Data.new(config_name, config))
+    update_sass_options!
+    null
+  rescue => e
+    puts e.backtrace.join("\n")
+    raise
+  end
+  declare :add_sass_configuration, [:project_path]
+
+  OPTION_TRANSFORMER = Hash.new() {|h, k| proc {|v, ctx| v.value } }
+  OPTION_TRANSFORMER[:asset_cache_buster] = proc do |v, ctx|
+    proc do |file|
+      if ctx.environment.function(v.value) || Sass::Script::Functions.callable?(v.value.tr('-', '_'))
+        result = ctx.call(v, ctx.quoted_string(file))
+        case result
+        when Sass::Script::Value::String, Sass::Script::Value::Null
+          result.value
+        else
+          ctx.assert_type(result, :Map) 
+          result.value.keys.inject({}) do |r, k|
+            ctx.assert_type k, :String
+            ctx.assert_type(result.value[k], :String) unless result.value[k].value.nil?
+            if k.value == "path" || k.value == "query"
+              r[k.value.to_sym] = result.value[k].value
+            end
+            r
+          end
+        end
+      else
+        raise ArgumentError, "#{v.value} is not a function."
+      end
+    end
+  end
+  OPTION_TRANSFORMER[:asset_host] = proc do |v, ctx|
+    proc do |file|
+      if ctx.environment.function(v.value) || Sass::Script::Functions.callable?(v.value.tr('-', '_'))
+        result = ctx.call(v, ctx.quoted_string(file))
+        case result
+        when Sass::Script::Value::String, Sass::Script::Value::Null
+          result.value
+        else
+          ctx.assert_type(result, :String)
+        end
+      else
+        raise ArgumentError, "#{v.value} is not a function."
+      end
+    end
+  end
+
+  def add_configuration(options)
+    attributes = {}
+    options.value.keys.each do |key|
+      underscored = key.value.to_s.tr("-", "_")
+      unless runtime_writable_attributes.find{|a| a.to_s == underscored}
+        raise ArgumentError, "#{key} is not a valid configuration option."
+      end
+      underscored = underscored.to_sym
+      attributes[underscored] = OPTION_TRANSFORMER[underscored].call(options.value[key], self)
+    end
+    name = "#{options.source_range.file}:#{options.source_range.start_pos.line}"
+    Compass.add_configuration(Compass::Configuration::Data.new(name, attributes))
+    update_sass_options!
+    null
+  end
+  declare :add_configuration, [:options]
+
+  private
+
+  def runtime_writable_attributes
+    Compass::Configuration::ATTRIBUTES - Compass::Configuration::RUNTIME_READONLY_ATTRIBUTES
+  end
+
+  def common_parent_directory(directory1, directory2)
+    relative = Pathname.new(directory1).relative_path_from(Pathname.new(directory2))
+    File.expand_path(directory2, relative.to_s.scan("..#{File::SEPARATOR}").join)
+  end
+
+  def relative_path_from(directory1, directory2)
+    Pathname.new(directory1).relative_path_from(Pathname.new(directory2)).to_s
+  end
+
+  def update_sass_options!
+    Compass.configuration.additional_import_paths.each do |lp|
+      options[:load_paths] << lp unless options[:load_paths].include?(lp)
+    end
+    if Compass.configuration.disable_warnings
+      Sass.logger.log_level = :error
+    else
+      Sass.logger.log_level = :warn
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Compass::Core::SassExtensions::Functions::Constants
+  POSITIONS = /top|bottom|left|right|center/
+  if defined?(Sass::Script::Value::List)
+    def is_position(position)
+      Sass::Script::Bool.new(position.is_a?(Sass::Script::String) && !!(position.value =~ POSITIONS))
+    end
+    def is_position_list(position_list)
+      Sass::Script::Bool.new(position_list.is_a?(Sass::Script::List) && position_list.value.all?{|p| is_position(p).to_bool})
+    end
+    # returns the opposite position of a side or corner.
+    def opposite_position(position)
+      position = unless position.is_a?(Sass::Script::List)
+        Sass::Script::List.new([position], :space)
+      else
+        Sass::Script::List.new(position.value.dup, position.separator)
+      end
+      position = Sass::Script::List.new(position.value.map do |pos|
+        if pos.is_a? Sass::Script::String
+          opposite = case pos.value
+          when "top" then "bottom"
+          when "bottom" then "top"
+          when "left" then "right"
+          when "right" then "left"
+          when "center" then "center"
+          else
+            Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+            pos.value
+          end
+          Sass::Script::String.new(opposite)
+        elsif pos.is_a? Sass::Script::Number
+          if pos.numerator_units == ["%"] && pos.denominator_units == []
+            Sass::Script::Number.new(100-pos.value, ["%"])
+          else
+            Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+            pos
+          end
+        else
+          Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+          pos
+        end
+      end, position.separator)
+      if position.value.size == 1
+        position.value.first
+      else
+        position
+      end
+    end
+
+    def is_url(string)
+      if string.is_a?(Sass::Script::String)
+        is_url = !!(string.value =~ /^url\(.*\)$/)
+        Sass::Script::Bool.new(is_url)
+      else
+        Sass::Script::Bool.new(false)
+      end
+    end
+  else
+    # returns the opposite position of a side or corner.
+    def opposite_position(position)
+      opposite = position.value.split(/ +/).map do |pos|
+        case pos
+        when "top" then "bottom"
+        when "bottom" then "top"
+        when "left" then "right"
+        when "right" then "left"
+        when "center" then "center"
+        else
+          pos
+        end
+      end
+      Sass::Script::String.new(opposite.join(" "), position.type)
+    end
+  end
+end

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

@@ -0,0 +1,269 @@
+module Compass::Core::SassExtensions::Functions::CrossBrowserSupport
+
+  class CSS2FallbackValue < Sass::Script::Literal
+    attr_accessor :value, :css2_value
+    def children
+      [value, css2_value]
+    end
+    def initialize(value, css2_value)
+      self.value = value
+      self.css2_value = css2_value
+    end
+    def inspect
+      to_s
+    end
+    def to_s(options = self.options)
+      value.to_s(options)
+    end
+    def supports?(aspect)
+      aspect == "css2"
+    end
+    def has_aspect?
+      true
+    end
+    def to_css2(options = self.options)
+      css2_value
+    end
+  end
+
+  # Check if any of the arguments passed require a vendor prefix.
+  def prefixed(prefix, *args)
+    assert_type prefix, :String
+    aspect = prefix.value.sub(/^-/,"")
+    needed = args.any?{|a| a.respond_to?(:supports?) && a.supports?(aspect)}
+    Sass::Script::Bool.new(needed)
+  end
+
+  %w(webkit moz o ms svg css2).each do |prefix|
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      # Syntactic sugar to apply the given prefix
+      # -moz($arg) is the same as calling prefix(-moz, $arg)
+      def _#{prefix}(*args)
+        prefix("#{prefix}", *args)
+      end
+    RUBY
+  end
+
+  def prefix(prefix, *objects)
+    assert_type prefix, :String if prefix.is_a?(Sass::Script::Value::Base)
+    prefix = prefix.value if prefix.is_a?(Sass::Script::String)
+    prefix = prefix[1..-1] if prefix[0] == ?-
+    if objects.size > 1
+      self.prefix(prefix, Sass::Script::List.new(objects, :comma))
+    else
+      object = objects.first
+      if object.is_a?(Sass::Script::List)
+        Sass::Script::List.new(object.value.map{|e|
+          self.prefix(prefix, e)
+        }, object.separator)
+      elsif object.respond_to?(:supports?) && object.supports?(prefix) && object.respond_to?(:"to_#{prefix}")
+        object.options = options
+        object.send(:"to_#{prefix}")
+      else
+        object
+      end
+    end
+  end
+
+  def css2_fallback(value, css2_value)
+    CSS2FallbackValue.new(value, css2_value)
+  end
+
+  # The known browsers.
+  #
+  # If prefix is given, limits the returned browsers to those using the specified prefix.
+  def browsers(prefix = nil)
+    browsers = if prefix
+                 assert_type prefix, :String
+                 Compass::Core::CanIUse.instance.browsers_with_prefix(prefix.value)
+               else
+                 Compass::Core::CanIUse.instance.browsers
+               end
+    list(browsers.map{|b| identifier(b)}, :comma)
+  end
+  Sass::Script::Functions.declare(:browsers, [])
+  Sass::Script::Functions.declare(:browsers, [:prefix])
+
+  # The known capabilities of browsers.
+  def browser_capabilities
+    list(Compass::Core::CanIUse.instance.capabilities.map{|c| identifier(c)}, :comma)
+  end
+  Sass::Script::Functions.declare(:browser_capabilities, [])
+
+  # The versions for the given browser.
+  def browser_versions(browser)
+    assert_type browser, :String
+    list(Compass::Core::CanIUse.instance.versions(browser.value).map{|v| quoted_string(v)}, :comma)
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:browser_versions, [:browser])
+
+  # whether the browser uses a prefix for the given capability at the version
+  # specified or a later version. Returns the prefix it requires, or null.
+  def browser_requires_prefix(browser, version, capability, capability_options)
+    assert_type browser, :String
+    assert_type version, :String
+    assert_type capability, :String
+    p = Compass::Core::CanIUse.instance.requires_prefix(browser.value,
+                                                  version.value,
+                                                  capability.value,
+                                                  unbox_capability_options_list(capability_options))
+    p ? identifier(p) : null()
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:browser_requires_prefix, [:browser, :version, :capability])
+
+  # the prefix for the given browser.
+  def browser_prefix(browser, version = nil)
+    assert_type browser, :String
+    identifier(Compass::Core::CanIUse.instance.prefix(browser.value))
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:browser_prefix, [:browser])
+  Sass::Script::Functions.declare(:browser_prefix, [:browser, :version])
+
+  # The prefixes used by the given browsers.
+  def browser_prefixes(browsers)
+    browsers = list(browsers, :comma) if browsers.is_a?(Sass::Script::Value::String)
+    assert_type browsers, :List
+    browser_strings = browsers.value.map {|b| assert_type(b, :String); b.value }
+    prefix_strings = Compass::Core::CanIUse.instance.prefixes(browser_strings)
+    list(prefix_strings.map {|p| identifier(p)}, :comma)
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:browser_prefixes, [:browsers])
+
+  # The percent of users that are omitted by setting the min_version of browser
+  # as specified.
+  def omitted_usage(browser, min_version, max_version = nil)
+    assert_type browser, :String
+    assert_type min_version, :String, :min_version
+    assert_type(max_version, :String, :max_version) if max_version
+    versions = [min_version.value]
+    versions << max_version.value if max_version
+    number(Compass::Core::CanIUse.instance.omitted_usage(browser.value, *versions))
+  end
+  Sass::Script::Functions.declare(:omitted_usage, [:browser, :min_version])
+  Sass::Script::Functions.declare(:omitted_usage, [:browser, :min_version, :max_version])
+
+  # The version before the version for the browser specified
+  def previous_version(browser, version)
+    assert_type browser, :String
+    assert_type version, :String
+    previous = Compass::Core::CanIUse.instance.previous_version(browser.value, version.value)
+    previous.nil? ? null() : quoted_string(previous)
+  end
+  Sass::Script::Functions.declare(:previous_version, [:browser, :version])
+
+  # The version before the version for the browser specified
+  def next_version(browser, version)
+    assert_type browser, :String
+    assert_type version, :String
+    next_version = Compass::Core::CanIUse.instance.next_version(browser.value, version.value)
+    next_version.nil? ? null() : quoted_string(next_version)
+  end
+  Sass::Script::Functions.declare(:next_version, [:browser, :version])
+
+  # The percent of users relying on a particular prefix
+  def prefix_usage(prefix, capability, capability_options)
+    assert_type prefix, :String
+    assert_type capability, :String
+    number(Compass::Core::CanIUse.instance.prefixed_usage(prefix.value,
+                                                    capability.value,
+                                                    unbox_capability_options_list(capability_options)))
+  rescue ArgumentError => e
+    raise Sass::SyntaxError.new(e.message)
+  end
+  Sass::Script::Functions.declare(:prefix_usage, [:prefix, :capability])
+
+  # Compares two browser versions. Returning:
+  #
+  # * 0 if they are the same
+  # * <0 if the first version is less than the second
+  # * >0 if the first version is more than the second
+  def compare_browser_versions(browser, version1, version2)
+    assert_type browser, :String, :browser
+    assert_type version1, :String, :version1
+    assert_type version2, :String, :version2
+    index1 = index2 = nil
+    Compass::Core::CanIUse.instance.versions(browser.value).each_with_index do |v, i|
+      index1 = i if v == version1.value
+      index2 = i if v == version2.value
+      break if index1 && index2
+    end
+    unless index1
+      raise Sass::SyntaxError.new("#{version1} is not a version for #{browser}")
+    end
+    unless index2
+      raise Sass::SyntaxError.new("#{version2} is not a version for #{browser}")
+    end
+    number(index1 <=> index2)
+  end
+  Sass::Script::Functions.declare(:compare_browser_versions, [:browser, :version1, :version2])
+
+  # Returns a map of browsers to the first version the capability became available
+  # without a prefix.
+  #
+  # If a prefix is provided, only those browsers using that prefix will be returned
+  # and the minimum version will be when it first became available as a prefix or
+  # without a prefix.
+  #
+  # If a browser does not have the capability, it will not included in the map.
+  def browser_ranges(capability, prefix = null(), include_unprefixed_versions = bool(true))
+    assert_type capability, :String
+    assert_type(prefix, :String) unless prefix == null()
+    mins = Compass::Core::CanIUse.instance.browser_ranges(capability.value,
+                                                          prefix.value,
+                                                          include_unprefixed_versions.to_bool)
+    Sass::Script::Value::Map.new(mins.inject({}) do |m, (h, range)|
+      m[identifier(h)] = list(range.map{|version| quoted_string(version)}, :space)
+      m
+    end)
+  end
+  Sass::Script::Functions.declare(:browser_minimums, [:capability])
+  Sass::Script::Functions.declare(:browser_minimums, [:capability, :prefix])
+
+  private
+
+  def unbox_capability_options_list(capability_options_list)
+    if capability_options_list.is_a?(Sass::Script::Value::Map)
+      [unbox_capability_options(capability_options_list)]
+    elsif capability_options_list.is_a?(Sass::Script::Value::List)
+      capability_options_list.to_a.map{|opts| unbox_capability_options(opts) }
+    else
+      assert_type capability_options_list, :List
+    end
+  end
+
+  CAPABILITY_OPTION_KEYS = {
+    "full-support" => :full_support,
+    "partial-support" => :partial_support,
+    "prefixed" => :prefixed,
+    "spec-versions" => :spec_versions,
+  }
+
+  CAPABILITY_OPTION_UNBOXER = {
+    :full_support => lambda {|v| v.to_bool },
+    :partial_support => lambda {|v| v.to_bool },
+    :prefixed => lambda {|v| v.to_bool },
+    :spec_versions => lambda {|versions| versions.to_a.map {|v| v.value } }
+  }
+
+  def unbox_capability_options(capability_options)
+    assert_type capability_options, :Map
+    result = {}
+    capability_options.value.each do |k, v|
+      assert_type k, :String
+      key = CAPABILITY_OPTION_KEYS[k.value]
+      unless key
+        raise Sass::SyntaxError, "#{k} is not valid capability option"
+      end
+      result[key] = CAPABILITY_OPTION_UNBOXER[key].call(v)
+    end
+    result
+  end
+end