compass-sourcemaps 0.12.2.sourcemaps.57a186c

data/lib/compass/configuration/paths.rb

@@ -0,0 +1,19 @@
+module Compass::Configuration::Paths
+
+  TRAILING_SEPARATOR = %r{.(/|#{Regexp.escape(File::SEPARATOR)})$}
+
+  def strip_trailing_separator(*attributes)
+    attributes.each do |attr|
+      alias_method "#{attr}_with_trailing_separator".to_sym, attr
+      class_eval %Q{
+        def #{attr}                                # def css_dir
+          path = #{attr}_with_trailing_separator   #   path = css_dir_with_trailing_separator
+          if path.to_s =~ TRAILING_SEPARATOR       #   if path =~ TRAILING_SEPARATOR
+            path = path[0..-($1.length+1)]         #     path = path[0..-($1.length+1)]
+          end                                      #   end
+          path                                     #   path
+        end                                        # end
+      }
+    end
+  end
+end

data/lib/compass/configuration/serialization.rb

@@ -0,0 +1,88 @@
+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
+          self.additional_import_paths ||= []
+          self.additional_import_paths += @added_import_paths
+          self.additional_import_paths.uniq!
+        end
+        issue_deprecation_warnings
+      end
+
+      def serialize
+        contents = ""
+        (required_libraries || []).each do |lib|
+          contents << %Q{require '#{lib}'\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
+  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/errors.rb

@@ -0,0 +1,11 @@
+module Compass
+  class Error < StandardError
+  end
+
+  class FilesystemConflict < Error
+  end
+
+  class MissingDependency < Error
+  end
+  class SpriteException < Error; end
+end

data/lib/compass/exec.rb

@@ -0,0 +1,23 @@
+require 'compass/dependencies'
+require 'optparse'
+require 'compass/logger'
+require 'compass/errors'
+require 'compass/actions'
+require 'compass/installers'
+require 'compass/commands'
+require 'rbconfig'
+require 'pathname'
+begin
+  require 'win32console' if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+rescue LoadError
+  $boring = true
+end
+
+module Compass::Exec
+end
+
+%w(helpers sub_command_ui
+   global_options_parser project_options_parser
+   command_option_parser).each do |lib|
+  require "compass/exec/#{lib}"
+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,63 @@
+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('--dry-run', :NONE, 'Dry Run. Tells you what it plans to do.') do
+      self.options[:dry_run] = 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

data/lib/compass/exec/project_options_parser.rb

@@ -0,0 +1,66 @@
+module Compass::Exec::ProjectOptionsParser
+  def set_options(opts)
+    super
+    set_project_options(opts)
+  end
+  def set_dir_or_path(type, dir)
+    if Pathname.new(dir).absolute?
+      self.options[:"#{type}_path"] = dir.tr('\\','/')
+    else
+      self.options[:"#{type}_dir"] = dir.tr('\\','/')
+    end
+  end
+
+  def set_project_options(opts)
+    opts.on('-c', '--config CONFIG_FILE', 'Specify the location of the configuration file explicitly.') do |configuration_file|
+      self.options[:configuration_file] = configuration_file
+    end
+
+    opts.on('--app APP', 'Tell compass what kind of application it is integrating with. E.g. rails') do |project_type|
+      self.options[:project_type] = project_type.to_sym
+    end
+
+    opts.on('--app-dir PATH', 'The base directory for your application.') do |project_path|
+      self.options[:project_path] = project_path
+    end
+
+    opts.on('--sass-dir SRC_DIR', "The source directory where you keep your sass stylesheets.") do |sass_dir|
+      set_dir_or_path(:sass, sass_dir)
+    end
+
+    opts.on('--css-dir CSS_DIR', "The target directory where you keep your css stylesheets.") do |css_dir|
+      set_dir_or_path(:css, css_dir)
+    end
+
+    opts.on('--images-dir IMAGES_DIR', "The directory where you keep your images.") do |images_dir|
+      set_dir_or_path(:images, images_dir)
+    end
+
+    opts.on('--javascripts-dir JS_DIR', "The directory where you keep your javascripts.") do |javascripts_dir|
+      set_dir_or_path(:javascripts, javascripts_dir)
+    end
+
+    opts.on('--fonts-dir FONTS_DIR', "The directory where you keep your fonts.") do |fonts_dir|
+      set_dir_or_path(:fonts, fonts_dir)
+    end
+
+    opts.on('-e ENV', '--environment ENV', [:development, :production], 'Use sensible defaults for your current environment.',
+            '  One of: development (default), production') do |env|
+      self.options[:environment] = env
+    end
+
+    opts.on('-s STYLE', '--output-style STYLE', [:nested, :expanded, :compact, :compressed], 'Select a CSS output mode.',
+            '  One of: nested, expanded, compact, compressed') do |style|
+      self.options[:output_style] = style
+    end
+
+    opts.on('--relative-assets', :NONE, 'Make compass asset helpers generate relative urls to assets.') do
+      self.options[:relative_assets] = true
+    end
+
+    opts.on('--no-line-comments', :NONE, 'Disable line comments.') do
+      self.options[:line_comments] = false
+    end
+  end
+
+end

data/lib/compass/exec/sub_command_ui.rb

@@ -0,0 +1,51 @@
+require 'compass/exec/global_options_parser'
+require 'compass/exec/project_options_parser'
+
+module Compass::Exec
+  class SubCommandUI
+
+    attr_accessor :args
+
+    def initialize(args)
+      self.args = args
+    end
+
+    def run!
+      begin
+        return perform!
+      rescue Exception => e
+        raise e if e.is_a? SystemExit
+        if e.is_a?(::Compass::Error) || e.is_a?(OptionParser::ParseError)
+          $stderr.puts e.message
+        else
+          ::Compass::Exec::Helpers.report_error(e, @options || {})
+        end
+        return 1
+      end
+    end
+    
+    protected
+    
+    def perform!
+      $command = args.shift
+      command_class = Compass::Commands[$command]
+      unless command_class
+        args.unshift($command)
+        $command = "help"
+        command_class = Compass::Commands::Default
+      end
+      @options = if command_class.respond_to?("parse_#{$command}!")
+        command_class.send("parse_#{$command}!", args)
+      else
+        command_class.parse!(args)
+      end
+      cmd = command_class.new(Dir.getwd, @options)
+      cmd.execute
+      cmd.successful? ? 0 : 1
+    rescue OptionParser::ParseError => e
+      puts "Error: #{e.message}"
+      puts command_class.usage if command_class.respond_to?(:usage)
+    end
+    
+  end
+end

data/lib/compass/exec/switch_ui.rb

@@ -0,0 +1,179 @@
+require 'compass/exec/global_options_parser'
+require 'compass/exec/project_options_parser'
+
+module Compass::Exec
+  class SwitchUI
+    include GlobalOptionsParser
+    include ProjectOptionsParser
+    attr_accessor :args, :options, :opts
+
+    def initialize(args)
+      self.args = args
+      self.options = {}
+      parse!
+    end
+
+    def run!
+      begin
+        perform!
+      rescue Exception => e
+        raise e if e.is_a? SystemExit
+        if e.is_a?(::Compass::Error) || e.is_a?(OptionParser::ParseError)
+          $stderr.puts e.message
+        else
+          ::Compass::Exec::Helpers.report_error(e, @options)
+        end
+        return 1
+      end
+      return 0
+    end
+    
+    protected
+    
+    def perform!
+      if options[:command]
+        do_command(options[:command])
+      else
+        puts self.opts
+      end
+    end
+    
+    def parse!
+      self.opts = OptionParser.new(&method(:set_opts))
+      self.opts.parse!(self.args)    
+      if self.args.size > 0
+        self.options[:project_name] = trim_trailing_separator(self.args.shift)
+      end
+      self.options[:command] ||= self.options[:project_name] ? :create_project : :update_project
+      self.options[:framework] ||= :compass
+    end
+
+    def trim_trailing_separator(path)
+      path[-1..-1] == File::SEPARATOR ? path[0..-2] : path
+    end
+
+    def set_opts(opts)
+      opts.banner = <<END
+Usage: compass [options] [project]
+
+Description:
+The compass command line tool will help you create and manage the stylesheets for your project.
+
+To get started on a stand-alone project based on blueprint:
+
+  compass -f blueprint my_compass_project
+
+When you change any sass files, you must recompile your project using --update or --watch.
+END
+      opts.separator ''
+      opts.separator 'Mode Options(only specify one):'
+
+      opts.on('-i', '--install', :NONE, "Create a new compass project.",
+                                        "  The default mode when a project is provided.") do
+        self.options[:command] = :create_project
+      end
+
+      opts.on('-u', '--update', :NONE, 'Update the current project.',
+                                       '  This is the default when no project is provided.') do
+        self.options[:command] = :update_project
+      end
+
+      opts.on('-w', '--watch', :NONE, 'Monitor the current project for changes and update') do
+        self.options[:command] = :watch_project
+        self.options[:quiet] = true
+      end
+
+      opts.on('-p', '--pattern PATTERN', 'Stamp out a pattern into the current project.',
+                                         '  Must be used with -f.') do |pattern|
+        self.options[:command] = :stamp_pattern
+        self.options[:pattern] = pattern
+      end
+
+      opts.on('-h', '--help') do
+        self.options[:command] = :help
+        self.options[:help_command] = :help
+      end
+
+      opts.on('--write-configuration', "Write the current configuration to the configuration file.") do
+        self.options[:command] = :write_configuration
+      end
+
+      opts.on('--list-frameworks', "List compass frameworks available to use.") do
+        self.options[:command] = :list_frameworks
+      end
+
+      opts.on('--validate', :NONE, 'Validate your project\'s compiled css. Requires Java.') do
+        self.options[:command] = :validate_project
+      end
+
+      opts.on('--grid-img [DIMENSIONS]', 'Generate a background image to test grid alignment.',
+                                         '  Dimension is given as <column_width>+<gutter_width>x<height>.',
+                                         '  Defaults to 30+10x20. Height is optional.') do |dimensions|
+        self.options[:grid_dimensions] = dimensions || "30+10"
+        self.options[:command] = :generate_grid_background
+      end
+
+      opts.separator ''
+      opts.separator 'Install/Pattern Options:'
+
+      opts.on('-f FRAMEWORK', '--framework FRAMEWORK', 'Use the specified framework. Only one may be specified.') do |framework|
+        self.options[:framework] = framework
+      end
+
+      opts.on('-n', '--pattern-name NAME', 'The name to use when stamping a pattern.',
+                                           '  Must be used in combination with -p.') do |name|
+        self.options[:pattern_name] = name
+      end
+
+      opts.on("-x", "--syntax SYNTAX", [:sass, :scss], "Specify the syntax to use when generating stylesheets.", "One of sass or scss. Defaults to scss.") do |syntax|
+        self.options[:preferred_syntax] = syntax
+      end
+
+      opts.on('--rails', "Sets the app type to a rails project (same as --app rails).") do
+        self.options[:project_type] = :rails
+      end
+
+      opts.on('--app APP_TYPE', 'Specify the kind of application to integrate with.') do |project_type|
+        self.options[:project_type] = project_type.to_sym
+      end
+
+      opts.separator ''
+      opts.separator 'Configuration Options:'
+
+      set_project_options(opts)
+
+      opts.separator ''
+      opts.separator 'General Options:'
+
+      set_global_options(opts)
+
+      opts.on('--imports', :NONE, 'Emit an imports suitable for passing to the sass command-line.',
+                                  '  Example: sass `compass --imports`',
+                                  '  Note: Compass\'s Sass extensions will not be available.') do
+        print ::Compass::Frameworks::ALL.map{|f| "-I #{f.stylesheets_directory}"}.join(' ')
+        exit
+      end
+
+      opts.on('--install-dir', :NONE, 'Emit the location where compass is installed.') do
+        puts ::Compass.base_directory
+        exit
+      end
+
+      opts.on_tail("-v", "--version", "Print version") do
+        self.options[:command] = :print_version
+      end
+
+      opts.on('--boring', :NONE, 'Turn off colorized output.') do
+        self.options[:color_output] = false
+      end
+
+    end
+    
+    def do_command(command)
+      command_class_name = command.to_s.split(/_/).map{|p| p.capitalize}.join('')
+      command_class = eval("::Compass::Commands::#{command_class_name}")
+      command_class.new(Dir.getwd, options).execute
+    end
+
+  end
+end