compass-core-sass37 1.1.0

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

@@ -0,0 +1,315 @@
+module Compass::Core::SassExtensions::Functions::Urls
+
+
+  def self.has?(base, instance_method)
+    # Sass::Util.has? was removed in Sass 3.7
+    # Use respond_to? directly instead
+    base.method_defined?(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 = bool(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
+        unquoted_string(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 = bool(false), cache_buster = bool(true))
+      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 unquoted_string("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.fonts_path, path.gsub(/[?#].*$/,""))
+      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
+        path, anchor = path.split("#", 2)
+        if cache_buster.is_a?(Sass::Script::Value::String)
+          path += "#{path["?"] ? "&" : "?"}#{cache_buster.value}"
+        else
+          path = cache_busted_path(path, real_path)
+        end
+        path = "#{path}#{"#" if anchor}#{anchor}"
+      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
+        unquoted_string(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 = bool(false), cache_buster = bool(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 unquoted_string("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.gsub(/#.*$/,""))
+      else
+        File.join(Compass.configuration.project_path, path.gsub(/#.*$/,""))
+      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
+        path, anchor = path.split("#", 2)
+        if cache_buster.is_a?(Sass::Script::Value::String)
+          path += "#{path["?"] ? "&" : "?"}#{cache_buster.value}"
+        else
+          path = cache_busted_path(path, real_path)
+        end
+        path = "#{path}#{"#" if anchor}#{anchor}"
+      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
+        unquoted_string(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 = bool(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 unquoted_string("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.generated_images_path
+        File.join(Compass.configuration.generated_images_path, path.gsub(/#.*$/,""))
+      else
+        File.join(Compass.configuration.project_path, path.gsub(/#.*$/,""))
+      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
+        path, anchor = path.split("#", 2)
+        if cache_buster.is_a?(Sass::Script::Value::String)
+          path += "#{path["?"] ? "&" : "?"}#{cache_buster.value}"
+        else
+          path = cache_busted_path(path, real_path)
+        end
+        path = "#{path}#{"#" if anchor}#{anchor}"
+      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)
+    unquoted_string("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])
+      target_path = Pathname.new(File.expand_path(path))
+      source_path = Pathname.new(File.dirname(File.expand_path(target_css_file)))
+      target_path.relative_path_from(source_path).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]
+      "#{path}#{path["?"] ? "&" : "?"}#{cache_buster[:query]}"
+    else
+      path
+    end
+  end
+
+  def compute_cache_buster(path, real_path)
+    file = nil
+    if Compass.configuration.asset_cache_buster
+      args = [path]
+      if Compass.configuration.asset_cache_buster.arity > 1
+        begin
+          file = File.new(real_path) if real_path
+        rescue Errno::ENOENT
+          # pass
+        end
+        args << file
+      end
+      Compass.configuration.asset_cache_buster.call(*args)
+    elsif real_path
+      default_cache_buster(path, real_path)
+    end
+  ensure
+    file.close if file
+  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

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

@@ -0,0 +1,41 @@
+module Compass::Core::SassExtensions::Functions
+  module SassDeclarationHelper
+    def declare(*args)
+      Sass::Script::Functions.declare(*args)
+    end
+  end
+end
+
+%w(
+  selectors    enumerate  urls      display
+  inline_image image_size constants gradient_support
+  font_files   lists      colors    math
+  env          cross_browser_support configuration
+  files
+).each do |func|
+  require "compass/core/sass_extensions/functions/#{func}"
+end
+
+module Sass::Script::Functions
+  include Compass::Core::SassExtensions::Functions::Configuration
+  include Compass::Core::SassExtensions::Functions::Selectors
+  include Compass::Core::SassExtensions::Functions::Enumerate
+  include Compass::Core::SassExtensions::Functions::Urls
+  include Compass::Core::SassExtensions::Functions::Display
+  include Compass::Core::SassExtensions::Functions::InlineImage
+  include Compass::Core::SassExtensions::Functions::ImageSize
+  include Compass::Core::SassExtensions::Functions::GradientSupport::Functions
+  include Compass::Core::SassExtensions::Functions::FontFiles
+  include Compass::Core::SassExtensions::Functions::Files
+  include Compass::Core::SassExtensions::Functions::Constants
+  include Compass::Core::SassExtensions::Functions::Lists
+  include Compass::Core::SassExtensions::Functions::Colors
+  include Compass::Core::SassExtensions::Functions::Math
+  include Compass::Core::SassExtensions::Functions::CrossBrowserSupport
+  include Compass::Core::SassExtensions::Functions::Env
+end
+
+# Wierd that this has to be re-included to pick up sub-modules. Ruby bug?
+class Sass::Script::Functions::EvaluationContext
+  include Sass::Script::Functions
+end

data/lib/compass/core/sass_extensions/monkey_patches/browser_support.rb

@@ -0,0 +1,119 @@
+require 'sass/script'
+
+module Sass::Script
+  module Value
+    class Base
+      NO_CHILDREN = []
+      def children
+        NO_CHILDREN
+      end
+
+      def opts(value)
+        value.options = options
+        value
+      end
+    end
+
+    class List < Base
+      def children
+        value
+      end
+    end
+
+    class ArgList < List
+      def children
+        super + @keywords.values
+      end
+    end
+
+    class Map < Base
+      def children
+        to_a
+      end
+    end
+  end
+  module HasSimpleCrossBrowserFunctionSupport
+    def supports?(aspect)
+      return true if Compass::BrowserSupport.supports?(name, aspect)
+      children.any? {|child| child.respond_to?(:supports?) && child.supports?(aspect) }
+    end
+
+    def has_aspect?(children = nil)
+      children ||= self.children
+      return true if Compass::BrowserSupport.has_aspect?(name)
+      children.any? {|child| child.respond_to?(:has_aspect?) && child.has_aspect? }
+    end
+  end
+
+  class CrossBrowserFunctionCall < Literal
+
+    attr_accessor :name, :args
+
+    include HasSimpleCrossBrowserFunctionSupport
+    include Sass::Script::Value::Helpers
+
+    def initialize(name, args)
+      self.name = name
+      self.args = args
+    end
+
+    def children
+      args
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s(options = self.options)
+      "#{name}(#{args.map{|a| a.to_s(options)}.join(", ")})"
+    end
+
+    %w(webkit moz o ms svg css2 owg).each do |prefix|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def to_#{prefix}(options = self.options)
+          prefixed_args = args.map do |arg|
+            arg.respond_to?(:to_#{prefix}) ? arg.to_#{prefix}(options) : arg
+          end
+          prefixed_name = if Compass::BrowserSupport.supports?(name, "#{prefix}")
+            "-#{prefix}-\#{name}"
+          else
+            name
+          end
+          contents = prefixed_args.join(', ')
+          if contents.size > 0
+            opts(identifier("\#{prefixed_name}(\#{contents})"))
+          else
+            opts(null)
+          end
+        end
+      RUBY
+    end
+
+  end
+
+  class Funcall < Node
+    include HasSimpleCrossBrowserFunctionSupport
+
+    alias sass_to_value to_value 
+
+    def to_value(args)
+      if has_aspect?(args)
+        CrossBrowserFunctionCall.new(name, args)
+      else
+        sass_to_value(args)
+      end
+    end
+  end
+
+  class List < Literal
+    def supports?(aspect)
+      children.any? {|child| child.respond_to?(:supports?) && child.supports?(aspect) }
+    end
+
+    def has_aspect?
+      children.any? {|child| child.respond_to?(:has_aspect?) && child.has_aspect? }
+    end
+  end
+
+end

data/lib/compass/core/sass_extensions/monkey_patches/traversal.rb

@@ -0,0 +1,23 @@
+module Sass
+  module Tree
+    class Node
+      unless method_defined?(:visit_depth_first)
+        def visit_depth_first(visitor)
+          visitor.visit(self)
+          visitor.down(self) if children.any? and visitor.respond_to?(:down)
+          if is_a?(ImportNode) && visitor.import?(self)
+            root = Sass::Engine.for_file(import, @options).to_tree
+            imported_children = root.children
+          end
+
+          (imported_children || children).each do |child|
+            break if visitor.respond_to?(:stop?) && visitor.stop?
+            child.visit_depth_first(visitor)
+          end
+          visitor.up(self) if children.any?
+        end
+      end
+    end
+  end
+end
+

data/lib/compass/core/sass_extensions/monkey_patches.rb

@@ -0,0 +1,3 @@
+%w(traversal browser_support).each do |patch|
+  require "compass/core/sass_extensions/monkey_patches/#{patch}"
+end

data/lib/compass/core/sass_extensions.rb

@@ -0,0 +1,10 @@
+require 'sass'
+unless Sass::Script::Functions.methods.grep(/\Adeclare\Z/).any?
+  raise LoadError, "It looks like you've got an incompatible version of Sass. This often happens when you have an old haml gem installed. Please upgrade Haml to v3.1 or above."
+end
+
+module Compass::Core::SassExtensions
+end
+
+require 'compass/core/sass_extensions/functions'
+require 'compass/core/sass_extensions/monkey_patches'

data/lib/compass/core/version.rb

@@ -0,0 +1,13 @@
+require 'compass/core/generated_version'
+
+module Compass
+  module Core
+    unless defined?(::Compass::Core::VERSION)
+      def self.scope(file)
+        File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", file))
+      end
+
+      VERSION = File.read(scope("VERSION")).strip
+    end
+  end
+end

data/lib/compass/core.rb

@@ -0,0 +1,78 @@
+require "compass/core/version"
+
+module Compass
+  module Core
+    class << self
+      attr_accessor :module_deprecation_warning_issued
+    end
+    def base_directory(*subdirs)
+      File.expand_path(File.join(File.dirname(__FILE__), '..', "..", *subdirs))
+    end
+    def lib_directory(*subdirs)
+      File.expand_path(File.join(File.dirname(__FILE__), "..", *subdirs))
+    end
+
+    module_function :base_directory, :lib_directory
+  end
+
+  module HasDeprecatedConstantsFromCore
+    def self.extended(base)
+      new_base = base.name.sub(/^Compass/,"Compass::Core")
+      base.class_eval <<-RUBY
+        def self.const_missing(const_name)
+          puts "cannot find \#{const_name}"
+          if #{new_base}.const_defined?(const_name)
+            unless Compass::Core.module_deprecation_warning_issued
+              Compass::Core.module_deprecation_warning_issued = true
+              Compass::Util.compass_warn(
+                "DEPRECATED: #{base.name}::\#{const_name} has been moved to " +
+                "#{new_base}::\#{const_name}.\\n" +
+                "Please update \#{caller[0]}")
+            end
+            #{new_base}.const_get(const_name)
+          end
+        end
+      RUBY
+    end
+  end
+
+  extend HasDeprecatedConstantsFromCore
+
+  module SassExtensions
+    extend HasDeprecatedConstantsFromCore
+
+    module Functions
+      extend HasDeprecatedConstantsFromCore
+    end
+  end
+
+  def shared_extension_paths
+    @shared_extension_paths ||= begin
+      if ENV["HOME"] && File.directory?(ENV["HOME"])
+        [File.join(ENV["HOME"], ".compass", "extensions")]
+      else
+        []
+      end
+    rescue ArgumentError # If HOME is relative
+      []
+    end
+  end
+  module_function :shared_extension_paths
+end
+
+require "sass"
+require "sass/plugin"
+require 'compass/util'
+require "compass/frameworks"
+require "compass/core/caniuse"
+require 'compass/core/sass_extensions'
+require 'compass/error'
+require 'compass/browser_support'
+require 'compass/configuration'
+
+Compass::Frameworks.register(
+  "compass",
+  :stylesheets_directory => Compass::Core.base_directory("stylesheets"),
+  :templates_directory => Compass::Core.base_directory("templates"),
+  :version => Compass::Core::VERSION
+)

data/lib/compass/error.rb

@@ -0,0 +1,5 @@
+module Compass
+  class Error < Sass::SyntaxError
+  end
+end
+