compass-sass37 1.1.0

data/lib/compass/commands/unpack_extension.rb

@@ -0,0 +1,120 @@
+require 'compass/commands/project_base'
+require 'fileutils'
+
+module Compass
+  module Commands
+    module ExtensionOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass unpack EXTENSION
+
+          Description:
+            Copy an extension into your extensions folder for easy access to the source code.
+            This makes it easier to peruse the source in unfamiliar projects. It is not recommended
+            that you change other extensions' source -- this makes it hard to take updates from
+            the original author. The following extensions are available:
+            
+          FRAMEWORKS
+            
+          Options:
+        }.strip.split("\n").map{|l| l.gsub(/^ {0,10}/,'')}.join("\n")
+        opts.banner.gsub!(/FRAMEWORKS/,Compass::Frameworks.pretty_print(true))
+        super
+      end
+    end
+
+    class UnpackExtension < ProjectBase
+
+      register :unpack
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        framework = Compass::Frameworks[options[:framework]]
+        unless framework
+          raise Compass::Error, "No extension named \"#{options[:framework]}\" was found."
+        end
+        files = Dir["#{framework.path}/**/*"]
+        extension_dir = File.join(Compass.configuration.extensions_path, framework.name)
+        FileUtils.rm_rf extension_dir
+        FileUtils.mkdir_p extension_dir
+        write_file File.join(extension_dir, "DO_NOT_MODIFY"), readme(framework)
+        files.each do |f|
+          next if File.directory?(f)
+          ending = f[(framework.path.size+1)..-1]
+          destination = File.join(extension_dir, ending)
+          FileUtils.mkdir_p(File.dirname(destination))
+          copy f, destination
+        end
+        puts "\nYou have unpacked \"#{framework.name}\""
+        puts
+        puts readme(framework)
+      end
+
+      def readme(framework)
+        %Q{| This is a copy of the "#{framework.name}" extension.
+           |
+           | It now overrides the original which was found here:
+           |
+           | #{framework.path}
+           |
+           | Unpacking an extension is useful when you need to easily peruse the
+           | extension's source. You might find yourself tempted to change the
+           | stylesheets here. If you do this, you'll find it harder to take
+           | updates from the original author. Sometimes this seems like a good
+           | idea at the time, but in a few months, you'll probably regret it.
+           |
+           | In the future, if you take an update of this framework, you'll need to run
+           |
+           |     compass unpack #{framework.name}
+           |
+           | again or remove this unpacked extension.
+           |}.gsub(/^\s*\| ?/,"")
+      end
+
+      def skip_extension_discovery?
+        true
+      end
+
+      class << self
+
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(ExtensionOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def description(command)
+          "Copy an extension into your extensions folder."
+        end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parse_arguments!(parser, arguments)
+          parser.options
+        end
+
+        def parse_arguments!(parser, arguments)
+          if arguments.size == 1
+            parser.options[:framework] = arguments.shift
+          elsif arguments.size == 0
+            raise Compass::Error, "Please specify an extension to unpack."
+          else
+            raise Compass::Error, "Too many arguments were specified."
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/compass/commands/update_project.rb

@@ -0,0 +1,148 @@
+require 'compass/commands/project_base'
+require 'compass/compiler'
+
+module Compass
+  module Commands
+    module CompileProjectOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass compile [path/to/project] [path/to/project/src/file.sass ...] [options]
+
+          Description:
+          compile project at the path specified or the current directory if not specified.
+
+          Options:
+        }.split("\n").map{|l| l.gsub(/^ */,'')}.join("\n")
+
+        opts.on("--[no-]sourcemap", "Generate a sourcemap during compilation.") do |sm|
+          self.options[:sourcemap] = sm
+        end
+
+        opts.on("--time", "Display compilation times.") do
+          self.options[:time] = true
+        end
+
+        opts.on("--debug-info", "Turns on sass's debuging information") do
+          self.options[:debug_info]= true
+        end
+
+        opts.on("--no-debug-info", "Turns off sass's debuging information") do
+          self.options[:debug_info]= false
+        end
+        super
+      end
+    end
+
+    class UpdateProject < ProjectBase
+
+      register :compile
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        compiler = new_compiler_instance
+        check_for_sass_files!(compiler)
+        prepare_project!(compiler)
+        compiler.compile!
+        if compiler.error_count > 0
+          compiler.logger.red do
+            compiler.logger.log "Compilation failed in #{compiler.error_count} files."
+          end
+          failed! 
+        end
+      end
+
+      def prepare_project!(compiler)
+        if options[:project_name]
+          Compass.configuration.project_path = File.expand_path(options[:project_name])
+        end
+
+        if config_file = new_config?(compiler)
+          compiler.logger.record :modified, relativize(config_file)
+          compiler.logger.record :clean, relativize(Compass.configuration.css_path)
+          compiler.clean!
+        end
+      end
+
+      # Determines if the configuration file is newer than any css file
+      def new_config?(compiler)
+        config_file = Compass.detect_configuration_file
+        return false unless config_file
+        config_mtime = File.mtime(config_file)
+        compiler.file_list.each do |(_, css_filename, _)|
+          return config_file if File.exist?(css_filename) && config_mtime > File.mtime(css_filename)
+        end
+        nil
+      end
+
+      def check_for_sass_files!(compiler)
+        file_list = compiler.file_list
+        if file_list.empty?
+          message = "Compass can't find any Sass files to compile.\nIs your compass configuration correct?.\nIf you're trying to start a new project, you have left off the directory argument.\n"
+          message << "Run \"compass -h\" to get help."
+          raise Compass::Error, message
+        elsif missing = file_list.find {|(sass_file, _, _)| !File.exist?(sass_file)}
+          raise Compass::Error, "File not found: #{missing[0]}"
+        end
+      end
+
+      def new_compiler_instance
+        Compass::SassCompiler.new(compiler_options)
+      end
+
+      def compiler_options
+        transfer_options(options, {}, :time, :debug_info, :only_sass_files, :force, :quiet)
+      end
+
+      def transfer_options(from, to, *keys)
+        keys.each do |k|
+          to[k] = from[k] unless from[k].nil?
+        end
+        to
+      end
+
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(CompileProjectOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def primary; true; end
+
+        def description(command)
+          "Compile Sass stylesheets to CSS"
+        end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parse_arguments!(parser, arguments)
+          parser.options
+        end
+
+        def parse_arguments!(parser, arguments)
+          if arguments.size > 0
+            parser.options[:project_name] = arguments.shift if File.directory?(arguments.first)
+            unless arguments.empty?
+              parser.options[:only_sass_files] = absolutize(*arguments)
+            end
+          end
+        end
+
+        def absolutize(*paths)
+          paths.map {|path| File.expand_path(path) }
+        end
+
+      end
+    end
+  end
+end

data/lib/compass/commands/validate_project.rb

@@ -0,0 +1,77 @@
+require 'compass/commands/project_base'
+require 'compass/commands/update_project'
+
+module Compass
+  module Commands
+    module ValidationOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass validate [path/to/project] [options]
+
+          Description:
+            Compile project at the path specified or the current
+            directory if not specified and then validate the 
+            generated CSS.
+
+          Options:
+        }.strip.split("\n").map{|l| l.gsub(/^ {0,10}/,'')}.join("\n")
+
+        super
+      end
+    end
+    class ValidateProject < ProjectBase
+
+      register :validate
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        require 'compass/validator'
+        UpdateProject.new(working_path, options).perform
+        Dir.chdir Compass.configuration.project_path do
+          Validator.new(project_css_subdirectory).validate()
+        end
+      end
+
+      class << self
+
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(ValidationOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def description(command)
+          "Validate your generated css."
+        end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parse_arguments!(parser, arguments)
+          parser.options
+        end
+
+        def parse_arguments!(parser, arguments)
+          if arguments.size == 1
+            parser.options[:project_name] = arguments.shift
+          elsif arguments.size == 0
+            # default to the current directory.
+          else
+            raise Compass::Error, "Too many arguments were specified."
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/compass/commands/watch_project.rb

@@ -0,0 +1,117 @@
+# encoding: UTF-8
+require 'fileutils'
+require 'pathname'
+require 'compass/commands/update_project'
+require "compass/sass_compiler"
+
+module Compass
+  module Commands
+    module WatchProjectOptionsParser
+      def set_options(opts)
+        super
+
+        opts.banner = %Q{
+          Usage: compass watch [path/to/project] [path/to/project/src/file.sass ...] [options]
+
+          Description:
+          watch the project for changes and recompile when they occur.
+
+          Options:
+        }.split("\n").map{|l| l.gsub(/^ */,'')}.join("\n")
+
+        opts.on("--poll", :NONE, "Check periodically if there's been changes.") do
+          self.options[:poll] = 1 # check every 1 second.
+        end
+
+      end
+    end
+
+    class WatchProject < UpdateProject
+
+      register :watch
+
+      attr_accessor :last_update_time, :last_sass_files
+
+      def perform
+        compiler = new_compiler_instance
+        compiler.logger.time = true if options[:time]
+        prepare_project!(compiler)
+        compiler.logger.log ">>> #{compiler.logger.color(:green)}Compass is watching for changes.#{compiler.logger.color(:clear)} #{compiler.logger.color(:red)}Press Ctrl-C to Stop.#{compiler.logger.color(:clear)}"
+        begin
+          compiler.watch!(:additional_watch_paths => additional_watch_paths, &method(:notify_watches))
+          happy_styling!(compiler.logger)
+        rescue Interrupt
+          happy_styling!(compiler.logger)
+        end
+      end
+
+      def happy_styling!(logger)
+          logger.log "\n#{logger.color(:yellow)}★★★ #{logger.color(:blue)}Happy Styling!#{logger.color(:yellow)} ★★★#{logger.color(:clear)}"
+      end
+
+      def compiler_options
+        super.merge(:poll => options[:poll], :full_exception => true)
+      end
+
+      def additional_watch_paths
+        Compass.configuration.watches.map do |watch|
+          pathname = Pathname.new(File.join(Compass.configuration.project_path, watch.glob))
+          real_path = nil
+          pathname.ascend do |p|
+            if p.exist?
+              real_path = p
+              break
+            end
+          end
+          real_path
+        end.compact.uniq
+      end
+
+      def notify_watches(modified, added, removed)
+        project_path = Compass.configuration.project_path
+        files = {:modified => modified,
+                 :added    => added,
+                 :removed  => removed}
+
+        run_once, run_each = Compass.configuration.watches.partition {|w| w.run_once_per_changeset?}
+
+        run_once.each do |watcher|
+          if file = files.values.flatten.detect{|f| watcher.match?(f) }
+            action = files.keys.detect{|k| files[k].include?(file) }
+            watcher.run_callback(project_path, relative_to(file, project_path), action)
+          end
+        end
+
+        run_each.each do |watcher|
+          files.each do |action, list|
+            list.each do |file|
+              if watcher.match?(file)
+                watcher.run_callback(project_path, relative_to(file, project_path), action)
+              end
+            end
+          end
+        end
+      end
+
+      def relative_to(f, dir)
+        Pathname.new(f).relative_path_from(Pathname.new(dir))
+      rescue ArgumentError # does not share a common path.
+        f
+      end
+
+      class << self
+        def description(command)
+          "Compile Sass stylesheets to CSS when they change"
+        end
+
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(CompileProjectOptionsParser)
+          parser.extend(WatchProjectOptionsParser)
+        end
+      end
+    end
+  end
+end

data/lib/compass/commands/write_configuration.rb

@@ -0,0 +1,125 @@
+require 'compass/commands/project_base'
+
+module Compass
+  module Commands
+    module ConfigurationOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass config [path/to/config_file.rb] [options]
+
+          Description:
+            Generate a configuration file for the options specified.
+            Compass will recognize configuration files in the
+            following locations relative to the project root:
+              * #{Compass::Configuration::Helpers::KNOWN_CONFIG_LOCATIONS.join("
+              * ")}
+            Any other location, and you'll need to specify it when working with the command line tool using the -c option.
+
+          Options:
+        }.strip.split("\n").map{|l| l.gsub(/^ {0,10}/,'')}.join("\n")
+        opts.on("--debug [PROPERTY]", "Debug your configuration by printing out details.") do |prop|
+          self.options[:debug] = prop.nil? ? true : prop.to_sym
+        end
+        opts.on("-p PROPERTY", "--property PROPERTY", "Print out the value of a particular configuration property") do |prop|
+          self.options[:display] = prop.to_sym
+        end
+
+        super
+      end
+    end
+    class WriteConfiguration < ProjectBase
+
+      register :config
+
+      include InstallerCommand
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def add_project_configuration
+        Compass.add_project_configuration
+      end
+
+      def perform
+        if options[:display]
+          if Compass.configuration.respond_to?(options[:display])
+            puts Compass.configuration.send(options[:display])
+          else
+            raise Compass::Error, "ERROR: configuration property '#{options[:display]}' does not exist"
+          end
+        elsif options[:debug]
+          puts "Configuration sources:"
+          c = Compass.configuration
+          while c
+            print c.name
+            c = c.inherited_data
+            print ", " if c
+          end
+          print "\n"
+          Compass.configuration.debug.each do |prop, values|
+            if options[:debug].is_a?(Symbol)
+              next unless prop == options[:debug]
+            end
+            puts "***** #{prop} = #{values.first[:resolved].inspect} *****"
+            [:default, :value, :raw, :resolved].each do |kind|
+              puts "#{kind}: " + values.inject([]){|m, v| m << v[kind]}.map{|v| v.nil? ? '-' : v.inspect}.join(", ")
+            end
+          end
+        else
+          config_file = options[:configuration_file]
+          config_file ||= Compass.detect_configuration_file
+          config_file ||= Compass::Configuration::Helpers::KNOWN_CONFIG_LOCATIONS.first
+          directory File.dirname(config_file)
+          installer.write_configuration_files(config_file)
+        end
+      end
+
+      def installer_args
+        [nil, project_directory, options]
+      end
+
+      def explicit_config_file_must_be_readable?
+        false
+      end
+
+      class << self
+
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(ConfigurationOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def description(command)
+          "Generate a configuration file for the provided command line options."
+        end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parse_arguments!(parser, arguments)
+          parser.options
+        end
+
+        def parse_arguments!(parser, arguments)
+          if arguments.size == 1
+            parser.options[:configuration_file] = arguments.shift
+          elsif arguments.size == 0
+            # default to the current directory.
+          else
+            raise Compass::Error, "Too many arguments were specified."
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/compass/commands.rb

@@ -0,0 +1,14 @@
+module Compass::Commands
+end
+
+require 'compass/commands/registry'
+
+%w(base project_base default help list_frameworks 
+   update_project watch_project create_project clean_project extension_command
+   imports installer_command print_version project_stats stamp_pattern
+   sprite validate_project write_configuration interactive unpack_extension
+).each do |lib|
+  require "compass/commands/#{lib}"
+end
+
+Compass.discover_extensions!