compass-sass37 1.1.0

data/lib/compass/compiler.rb

@@ -0,0 +1,249 @@
+require 'pathname'
+
+module Compass
+  class Compiler
+
+    include Actions
+
+    attr_accessor :working_path, :from, :to, :options, :sass_options, :staleness_checker, :importer
+
+    def initialize(working_path, from, to, options)
+      Compass::Deprecation.deprecated!(:compass_compiler_constructor,
+        "Compass::Compiler is deprecated. Use Compass::SassCompiler instead.")
+      self.working_path = working_path.to_s
+      self.from, self.to = File.expand_path(from), to
+      self.logger = options.delete(:logger)
+      sass_opts = options.delete(:sass) || {}
+      self.options = options
+      self.sass_options = options.dup
+      self.sass_options.delete(:quiet)
+      self.sass_options.update(sass_opts)
+      self.sass_options[:cache_location] ||= determine_cache_location
+      self.sass_options[:filesystem_importer] ||= Sass::Importers::Filesystem
+      self.sass_options[:importer] = self.importer = self.sass_options[:filesystem_importer].new(from)
+      self.sass_options[:compass] ||= {}
+      self.sass_options[:compass][:logger] = self.logger
+      self.sass_options[:compass][:environment] = Compass.configuration.environment
+      self.sass_options[:compass][:compiler_in_use] = true
+      reset_staleness_checker!
+    end
+
+    def reset_staleness_checker!
+      self.staleness_checker = nil
+      #Sass::Plugin::StalenessChecker.dependencies_cache = {}
+      self.staleness_checker = Sass::Plugin::StalenessChecker.new(sass_options)
+    end
+
+    def determine_cache_location
+      Compass.configuration.cache_path || Sass::Plugin.options[:cache_location] || File.join(working_path, ".sass-cache")
+    end
+
+    def sass_files(options = {})
+      exclude_partials = options.fetch(:exclude_partials, true)
+      @sass_files = self.options[:sass_files] || Dir.glob(separate("#{from}/**/#{'[^_]' if exclude_partials}*.s[ac]ss"))
+    end
+
+    def relative_stylesheet_name(sass_file)
+      sass_file[(from.length + 1)..-1]
+    end
+
+    def stylesheet_name(sass_file)
+      if sass_file.index(from) == 0
+        sass_file[(from.length + 1)..-6].sub(/\.css$/,'')
+      else
+        raise Compass::Error, "You must compile individual stylesheets from the project directory."
+      end
+    end
+
+    def css_files
+      @css_files ||= sass_files.map{|sass_file| corresponding_css_file(sass_file)}
+    end
+
+    def sourcemap_files
+      @sourcemap_files ||= sass_files.map{|sass_file| corresponding_sourcemap_file(sass_file)}
+    end
+
+    def corresponding_css_file(sass_file)
+      "#{to}/#{stylesheet_name(sass_file)}.css"
+    end
+
+    def corresponding_sourcemap_file(sass_file)
+      "#{to}/#{stylesheet_name(sass_file)}.css.map"
+    end
+
+    def target_directories
+      css_files.map{|css_file| File.dirname(css_file)}.uniq.sort.sort_by{|d| d.length }
+    end
+
+    # Returns the sass file that needs to be compiled, if any.
+    def out_of_date?
+      sass_files.zip(css_files).each do |sass_filename, css_filename|
+        return sass_filename if needs_update?(css_filename, sass_filename)
+      end
+      false
+    end
+
+    def needs_update?(css_filename, sass_filename)
+      staleness_checker.stylesheet_needs_update?(css_filename, File.expand_path(sass_filename), importer)
+    end
+
+    # Determines if the configuration file is newer than any css file
+    def new_config?
+      config_file = Compass.detect_configuration_file
+      return false unless config_file
+      config_mtime = File.mtime(config_file)
+      css_files.each do |css_filename|
+        return config_file if File.exist?(css_filename) && config_mtime > File.mtime(css_filename)
+      end
+      nil
+    end
+
+    def reset!
+      reset_staleness_checker!
+      @sass_files = nil
+      @css_files = nil
+      @sourcemap_files = nil
+    end
+
+    def clean!
+      remove options[:cache_location]
+      css_files.zip(sourcemap_files).each do |css_file, sourcemap_file|
+        remove css_file
+        remove sourcemap_file
+      end
+    end
+
+    def run
+      failure_count = 0
+      if new_config?
+        # Wipe out the cache and force compilation if the configuration has changed.
+        remove options[:cache_location] if options[:cache_location]
+        options[:force] = true
+      end
+
+      # Make sure the target directories exist
+      target_directories.each {|dir| directory dir}
+
+      # Compile each sass file.
+      result = timed do
+        sass_files.zip(css_files, sourcemap_files).each do |sass_filename, css_filename, sourcemap_filename|
+          begin
+            compile_if_required sass_filename, css_filename, sourcemap_filename
+          rescue Sass::SyntaxError => e
+            failure_count += 1
+            handle_exception(sass_filename, css_filename, e)
+          end
+        end
+      end
+      if options[:time]
+        puts "Compilation took #{(result.__duration * 1000).round / 1000.0}s"
+      end
+      return failure_count
+    end
+
+    def compile_if_required(sass_filename, css_filename, sourcemap_filename = nil)
+      if should_compile?(sass_filename, css_filename, sourcemap_filename)
+        compile sass_filename, css_filename, sourcemap_filename
+      else
+        logger.record :unchanged, basename(sass_filename) unless options[:quiet]
+        remove(sourcemap_filename) if sourcemap_filename && !options[:sourcemap]
+      end
+    end
+
+    def timed(timed_thing = lambda {|res| res})
+      start_time = Time.now
+      res = yield
+      end_time = Time.now
+      has_duration = timed_thing.call(res)
+      has_duration.instance_variable_set("@__duration", end_time - start_time)
+      def has_duration.__duration
+        @__duration
+      end
+      res
+    end
+
+    # Compile one Sass file
+    def compile(sass_filename, css_filename, sourcemap_filename = nil)
+      css_content, sourcemap = logger.red do
+        timed(lambda {|r| r[0]}) do
+          engine = engine(sass_filename, css_filename, sourcemap_filename)
+          if sourcemap_filename && options[:sourcemap]
+            engine.render_with_sourcemap(relative_path(css_filename, sourcemap_filename))
+          else
+            [engine.render, nil]
+          end
+        end
+      end
+      duration = options[:time] ? "(#{(css_content.__duration * 1000).round / 1000.0}s)" : ""
+      write_file(css_filename, css_content, options.merge(:force => true, :extra => duration), sass_options[:unix_newlines])
+      Compass.configuration.run_stylesheet_saved(css_filename)
+      if sourcemap && sourcemap_filename
+        sourcemap_content = sourcemap.to_json(:css_path => css_filename,
+                                              :sourcemap_path => sourcemap_filename)
+        write_file(sourcemap_filename, sourcemap_content, options.merge(:force => true), sass_options[:unix_newlines])
+        Compass.configuration.run_sourcemap_saved(sourcemap_filename)
+      elsif sourcemap_filename && File.exist?(sourcemap_filename)
+        remove sourcemap_filename
+        Compass.configuration.run_sourcemap_removed(sourcemap_filename)
+      end
+    end
+
+    def relative_path(from_path, to_path)
+      Pathname.new(to_path).relative_path_from(Pathname.new(from_path).dirname).to_s
+    end
+
+    def should_compile?(sass_filename, css_filename, sourcemap_filename = nil)
+      return true if css_filename && !File.exist?(css_filename)
+      return true if sourcemap_filename && options[:sourcemap] && !File.exist?(sourcemap_filename)
+      options[:force] ||
+        needs_update?(css_filename, sass_filename) ||
+        (options[:sourcemap] && needs_update?(sourcemap_filename, sass_filename))
+    end
+
+    # A sass engine for compiling a single file.
+    def engine(sass_filename, css_filename, sourcemap_filename = nil)
+      syntax = (sass_filename =~ /\.(s[ac]ss)$/) && $1.to_sym || :sass
+      opts = sass_options.merge(:filename => sass_filename,
+                                :css_filename => css_filename,
+                                :syntax => syntax,
+                                :sourcemap_filename => sourcemap_filename)
+      Sass::Engine.new(open(sass_filename).read, opts)
+    end
+
+    # Place the syntax error into the target css file,
+    # formatted to display in the browser (in development mode)
+    # if there's an error.
+    def handle_exception(sass_filename, css_filename, e)
+      exception_file = basename(e.sass_filename || sass_filename)
+      file = basename(sass_filename)
+      exception_file = nil if exception_file == file
+      formatted_error = "(Line #{e.sass_line}#{ " of #{exception_file}" if exception_file}: #{e.message})"
+      logger.record :error, file, formatted_error
+      Compass.configuration.run_stylesheet_error(sass_filename, formatted_error)
+      write_file css_filename, error_contents(e, sass_filename), options.merge(:force => true), sass_options[:unix_newlines]
+    end
+
+    # Haml refactored this logic in 2.3, this is backwards compatibility for either one
+    def error_contents(e, sass_filename)
+      if show_full_exception?
+        e.sass_template = sass_filename
+        Sass::SyntaxError.exception_to_css(e)
+      else
+        header = Sass::SyntaxError.send(:header_string, e, 1)
+        <<END
+/*
+#{header.gsub("*/", "*\\/")}
+
+Backtrace:\n#{e.backtrace.join("\n").gsub("*/", "*\\/")}
+*/
+END
+      end
+    end
+
+    # We don't want to show the full exception in production environments.
+    def show_full_exception?
+      Compass.configuration.environment == :development
+    end
+
+  end
+end

data/lib/compass/configuration/comments.rb

@@ -0,0 +1,62 @@
+module Compass
+  module Configuration
+    # Comments are emitted into the configuration file when serialized and make it easier to understand for new users.
+    module Comments
+
+      def comment_for_http_path
+        unless top_level.http_path_without_default
+          "# Set this to the root of your project when deployed:\nhttp_path = #{top_level.http_path.to_s.inspect}\n"
+        else
+          ""
+        end
+      end
+
+      def comment_for_relative_assets
+        unless top_level.relative_assets
+          %q{# To enable relative paths to assets via compass helper functions. Uncomment:
+# relative_assets = true
+}
+        else
+          ""
+        end
+      end
+
+      def comment_for_line_comments
+        if top_level.line_comments
+          %q{# To disable debugging comments that display the original location of your selectors. Uncomment:
+# line_comments = false
+}
+        else
+          ""
+        end
+      end
+
+      def comment_for_output_style
+        unless top_level.output_style_without_default
+          %Q{# You can select your preferred output style here (can be overridden via the command line):
+# output_style = :expanded or :nested or :compact or :compressed
+}
+        else
+          ""
+        end
+      end
+
+      def comment_for_preferred_syntax
+        if top_level.preferred_syntax_without_default.nil? && top_level.sass_dir
+          %Q{
+# If you prefer the indented syntax, you might want to regenerate this
+# project again passing --syntax sass, or you can uncomment this:
+# preferred_syntax = :sass
+# and then run:
+# sass-convert -R --from scss --to sass #{top_level.sass_dir} scss && rm -rf sass && mv scss sass
+}
+        else
+          ""
+        end
+      end
+    end
+    class Data
+      include Comments
+    end
+  end
+end

data/lib/compass/configuration/file_data.rb

@@ -0,0 +1,21 @@
+module Compass
+  module Configuration
+    class FileData < Data
+      def self.new_from_file(config_file, defaults = nil)
+        data = new(config_file)
+        data.with_defaults(defaults) do
+          data._parse(config_file)
+        end
+        data
+      end
+
+      def self.new_from_string(contents, filename, defaults = nil)
+        data = new(filename)
+        data.with_defaults(defaults) do
+          data.parse_string(contents, filename)
+        end
+        data
+      end
+    end
+  end
+end

data/lib/compass/configuration/helpers.rb

@@ -0,0 +1,113 @@
+module Compass
+  module Configuration
+    @callbacks_loaded = false
+    # The helpers are available as methods on the Compass module. E.g. Compass.configuration
+    module Helpers
+      def configuration_for(config, filename = nil, defaults = nil)
+        if config.nil?
+          nil
+        elsif config.is_a?(Compass::Configuration::Data)
+          config
+        elsif config.instance_of?(Hash)
+          Compass::Configuration::Data.new(filename, config)
+        elsif config.respond_to?(:read)
+          filename ||= config.to_s if config.is_a?(Pathname)
+          Compass::Configuration::FileData.new_from_string(config.read, filename, defaults)
+        elsif config.is_a?(Hash)
+          Compass::Configuration::Data.new(filename, config)
+        elsif config.is_a?(String)
+          Compass::Configuration::FileData.new_from_file(config, defaults)
+        elsif config.is_a?(Symbol)
+          Compass::AppIntegration.lookup(config).configuration
+        else
+          raise "I don't know what to do with: #{config.inspect}"
+        end
+      end
+
+      def sass_plugin_configuration
+        configuration.to_sass_plugin_options
+      end
+
+      def configure_sass_plugin!
+        require 'sass/plugin'
+        config = sass_plugin_configuration
+        locations = config.delete(:template_location)
+        Sass::Plugin.options.merge!(config)
+        locations.each do |sass_dir, css_dir|
+          unless Sass::Plugin.engine_options[:load_paths].include?(sass_dir)
+            Sass::Plugin.add_template_location sass_dir, css_dir
+          end
+        end
+        unless @callbacks_loaded
+          on_saved = Proc.new do |sass_file, css_file|
+                       Compass.configuration.run_stylesheet_saved(css_file)
+                     end
+          if Sass::Plugin.respond_to?(:on_updated_stylesheet)
+            Sass::Plugin.on_updated_stylesheet(&on_saved)
+          else
+            Sass::Plugin.on_updating_stylesheet(&on_saved)
+          end
+          
+          Sass::Plugin.on_compilation_error do |e, filename, css|
+            Compass.configuration.run_stylesheet_error(filename, e.message)
+          end
+          
+          @callbacks_loaded = true
+        end
+      end
+
+      def sass_engine_options
+        configuration.to_sass_engine_options
+      end
+
+      # Read the configuration file for this project
+      def add_project_configuration(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        configuration_file_path = args.shift || detect_configuration_file
+
+        raise ArgumentError, "Too many arguments" if args.any?
+        if AppIntegration.default? && data = configuration_for(configuration_file_path, nil, configuration_for(options[:defaults]))
+          if data.raw_project_type
+            add_configuration(data.raw_project_type.to_sym)
+          elsif options[:project_type]
+            add_configuration(options[:project_type])
+          else
+            add_configuration(:stand_alone)
+          end
+          add_configuration(data)
+        else
+          add_configuration(options[:project_type] || configuration.project_type_without_default || (yield if block_given?) || :stand_alone)
+        end
+      end
+
+      # TODO: Deprecate the src/config.rb location.
+      KNOWN_CONFIG_LOCATIONS = ['config/compass.rb', ".compass/config.rb", "config/compass.config", "config.rb", "src/config.rb"]
+
+      # Finds the configuration file, if it exists in a known location.
+      def detect_configuration_file(project_path = nil)
+        possible_files = KNOWN_CONFIG_LOCATIONS.map{|f| projectize(f, project_path) }
+        possible_files.detect{|f| File.exist?(f)}
+      end
+
+      def handle_configuration_change!
+        if (compiler = Compass.compiler).new_config?
+          compiler.clean!
+        end
+      end
+
+      # @deprecated
+      def compiler
+        Compass::Deprecation.deprecated!(:compiler_accessor,
+          "Compass.compiler is deprecated. Use Compass.sass_compiler instead.")
+        Compass::Deprecation.mark_as_issued(:compass_compiler_constructor)
+        Compass::Compiler.new(*Compass.configuration.to_compiler_arguments)
+      end
+
+      def sass_compiler(*args)
+        Compass::SassCompiler.new(*args)
+      end
+    end
+  end
+
+  extend Configuration::Helpers
+end

data/lib/compass/configuration/serialization.rb

@@ -0,0 +1,95 @@
+module Compass
+  module Configuration
+    # The serialization module manages reading and writing the configuration file(s).
+    module Serialization
+      def parse(config_file)
+        raise Compass::Error, "Compass.configuration.parse(filename) has been removed. Please call Compass.add_project_configuration(filename) instead."
+      end
+
+      # parses a configuration file which is a ruby script
+      def _parse(config_file)
+        unless File.readable?(config_file)
+          raise Compass::Error, "Configuration file, #{config_file}, not found or not readable."
+        end
+        open(config_file) do |f|
+          parse_string(f.read, config_file)
+        end
+      end
+
+      def get_binding
+        binding
+      end
+      def parse_string(contents, filename)
+        bind = get_binding
+        eval(contents, bind, filename)
+        local_vars_set = eval("local_variables", bind)
+        local_vars_set.each do |local_var|
+          if (ATTRIBUTES+ARRAY_ATTRIBUTES).include?(local_var.to_sym)
+            value = eval(local_var.to_s, bind)
+            value = value.to_s if value.is_a?(Pathname)
+            self.send("#{local_var}=", value)
+          end
+        end
+        if @added_import_paths
+          @added_import_paths.each do |p|
+            self.additional_import_paths << p unless self.additional_import_paths.include?(p)
+          end
+        end
+        issue_deprecation_warnings
+      end
+
+      def serialize
+        contents = ""
+        (required_libraries || []).each do |lib|
+          contents << %Q{require '#{lib}'\n}
+        end
+        unless (required_libraries || []).include?("compass/import-once/activate") ||
+               (required_libraries || []).include?("compass/import-once")
+          contents << "require 'compass/import-once/activate'\n"
+        end
+        (loaded_frameworks || []).each do |lib|
+          contents << %Q{load '#{lib}'\n}
+        end
+        (framework_path || []).each do |lib|
+          contents << %Q{discover '#{lib}'\n}
+        end
+        contents << "# Require any additional compass plugins here.\n"
+        contents << "\n" if (required_libraries || []).any?
+        (ATTRIBUTES + ARRAY_ATTRIBUTES).each do |prop|
+          value = send("#{prop}_without_default")
+          if value.is_a?(Proc)
+            $stderr.puts "WARNING: #{prop} is code and cannot be written to a file. You'll need to copy it yourself."
+          end
+          if respond_to?("comment_for_#{prop}")
+            contents << "\n"
+            contents << send("comment_for_#{prop}")
+          end
+          if block_given? && (to_emit = yield(prop, value))
+            contents << to_emit
+          else
+            contents << serialize_property(prop, value) unless value.nil?
+          end
+        end
+        contents
+      end
+
+      def serialize_property(prop, value)
+        if value.respond_to?(:serialize_to_config)
+          value.serialize_to_config(prop) + "\n"
+        else
+          %Q(#{prop} = #{value.inspect}\n)
+        end
+      end
+
+      def issue_deprecation_warnings
+        if http_images_path == :relative
+          $stderr.puts "DEPRECATION WARNING: Please set relative_assets = true to enable relative paths."
+        end
+      end
+
+    end
+    class Data
+      include Serialization
+    end
+  end
+end

data/lib/compass/dependencies.rb

@@ -0,0 +1,12 @@
+begin
+  require 'sass'
+rescue LoadError
+  require 'rubygems'
+  begin
+    require 'sass'
+  rescue LoadError
+    puts "Unable to load Sass. Please install it with one of the following commands:"
+    puts "  gem install sass --pre"
+    raise
+  end
+end

data/lib/compass/deprecation.rb

@@ -0,0 +1,19 @@
+module Compass
+  module Deprecation
+    class << self
+      attr_accessor :issued_deprecations
+    end
+    self.issued_deprecations = {}
+
+    def self.deprecated!(identifier, message)
+      return if Deprecation.issued_deprecations[identifier]
+      Deprecation.issued_deprecations[identifier] = true
+      warn message
+      warn "Called from #{caller[1]}"
+    end
+
+    def self.mark_as_issued(identifier)
+      Deprecation.issued_deprecations[identifier] = true
+    end
+  end
+end

data/lib/compass/errors.rb

@@ -0,0 +1,9 @@
+require 'compass/error'
+module Compass
+  class FilesystemConflict < Error
+  end
+
+  class MissingDependency < Error
+  end
+  class SpriteException < Error; end
+end

data/lib/compass/exec/command_option_parser.rb

@@ -0,0 +1,23 @@
+module Compass::Exec
+  class CommandOptionParser
+    attr_accessor :options, :arguments, :opts
+    def initialize(arguments)
+      self.arguments = arguments
+      self.options = {}
+    end
+    def parse!
+      opts.parse!(arguments)
+    end
+    def opts
+      OptionParser.new do |opts|
+        self.set_options(opts)
+      end
+    end
+    def set_options(opts)
+
+    end
+    def to_s
+      opts.to_s
+    end
+  end
+end

data/lib/compass/exec/global_options_parser.rb

@@ -0,0 +1,59 @@
+module Compass::Exec::GlobalOptionsParser
+  def set_options(opts)
+    super
+    set_global_options(opts)
+  end
+  def set_global_options(opts)
+    opts.on('-r LIBRARY', '--require LIBRARY',
+            "Require the given ruby LIBRARY before running commands.",
+            "  This is used to access compass plugins without having a",
+            "  project configuration file."
+      ) do |library|
+        ::Compass.configuration.require library
+      end
+
+    opts.on('-l FRAMEWORK_DIR', '--load FRAMEWORK_DIR',
+            "Load the framework or extensions found in the FRAMEWORK directory."
+      ) do |framework_dir|
+        require 'pathname'
+        ::Compass.configuration.load Pathname.new(framework_dir).realpath
+      end
+
+    opts.on('-L FRAMEWORKS_DIR', '--load-all FRAMEWORKS_DIR',
+            "Load all the frameworks or extensions found in the FRAMEWORKS_DIR directory."
+      ) do |frameworks_dir|
+        require 'pathname'
+        ::Compass.configuration.discover Pathname.new(frameworks_dir).realpath
+      end
+
+    opts.on('-I IMPORT_PATH', '--import-path IMPORT_PATH',
+            "Makes files under the IMPORT_PATH folder findable by Sass's @import directive."
+      ) do |import_path|
+        require 'pathname'
+        ::Compass.configuration.add_import_path Pathname.new(import_path).realpath
+      end
+
+    opts.on('-q', '--quiet', :NONE, 'Quiet mode.') do
+      self.options[:quiet] = true
+    end
+
+    opts.on('--trace', :NONE, 'Show a full stacktrace on error') do
+      self.options[:trace] = true
+    end
+
+    opts.on('--force', :NONE, 'Allows compass to overwrite existing files.') do
+      self.options[:force] = true
+    end
+
+    opts.on('--boring', :NONE, 'Turn off colorized output.') do
+      self.options[:color_output] = false
+    end
+
+    opts.on_tail("-?", "-h", "--help", "Show this message") do
+      puts opts
+      exit
+    end
+
+  end
+
+end

data/lib/compass/exec/helpers.rb

@@ -0,0 +1,21 @@
+module Compass::Exec
+  module Helpers
+    extend self
+    def report_error(e, options)
+      $stderr.puts "#{e.class} on line #{get_line e} of #{get_file e}: #{e.message}"
+      if options[:trace]
+        e.backtrace[1..-1].each { |t| $stderr.puts "  #{t}" }
+      else
+        $stderr.puts "Run with --trace to see the full backtrace"
+      end
+    end
+
+    def get_file(exception)
+      exception.backtrace[0].split(/:/, 2)[0]
+    end
+
+    def get_line(exception)
+      exception.backtrace[0].scan(/:(\d+)/)[0]
+    end
+  end
+end