compass-sourcemaps 0.12.2.sourcemaps.57a186c

data/lib/compass/commands/stamp_pattern.rb

@@ -0,0 +1,90 @@
+require 'fileutils'
+require 'compass/commands/base'
+require 'compass/commands/update_project'
+
+module Compass
+  module Commands
+    module StampPatternOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{Usage: compass install extension/pattern [path/to/project] [options]
+
+Description:
+  Install an extension's pattern into your compass project
+
+Example:
+  compass install blueprint/buttons
+
+Options:
+}
+        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
+
+        super
+      end
+    end
+
+    class StampPattern < ProjectBase
+
+      register :install
+
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(StampPatternOptionsParser)
+        end
+        def usage
+          option_parser([]).to_s
+        end
+        def description(command)
+          "Install an extension's pattern into your compass project"
+        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
+            raise OptionParser::ParseError, "Please specify a pattern."
+          end
+          pattern = arguments.shift.split('/', 2)
+          parser.options[:framework] = pattern[0]
+          parser.options[:pattern] = pattern[1]
+          if arguments.size > 0
+            parser.options[:project_name] = arguments.shift
+          end
+          if arguments.size > 0
+            raise OptionParser::ParseError, "Unexpected trailing arguments: #{arguments.join(" ")}"
+          end
+        end
+
+      end
+      include InstallerCommand
+
+      def initialize(working_path, options)
+        super(working_path, options)
+      end
+
+      # all commands must implement perform
+      def perform
+        installer.init
+        installer.run(:skip_finalization => true, :skip_preparation => !is_project_creation?)
+        UpdateProject.new(working_path, options).perform if installer.compilation_required?
+        installer.finalize(options.merge(:create => is_project_creation?))
+      end
+
+      def is_project_creation?
+        false
+      end
+
+      def template_directory(pattern)
+        File.join(framework.templates_directory, pattern)
+      end
+
+    end
+  end
+end

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,139 @@
+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("--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! unless dry_run?
+      end
+
+      def perform
+        compiler = new_compiler_instance
+        check_for_sass_files!(compiler)
+        compiler.clean! if compiler.new_config?
+        error_count = compiler.run
+        failed! if error_count > 0
+      end
+
+      def check_for_sass_files!(compiler)
+        if compiler.sass_files.empty? && !dry_run?
+          message = "Nothing to compile. If 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
+        end
+      end
+
+      def dry_run?
+        options[:dry_run]
+      end
+
+      def new_compiler_instance(additional_options = {})
+        @compiler_opts ||= begin
+          compiler_opts = {:sass => Compass.sass_engine_options}
+          compiler_opts.merge!(options)
+          compiler_opts[:sass_files] = explicit_sass_files
+          compiler_opts[:cache_location] = determine_cache_location
+          if options.include?(:debug_info) && options[:debug_info]
+            compiler_opts[:sass][:debug_info] = options.delete(:debug_info)
+          end
+          compiler_opts
+        end
+
+        @memory_store ||= Sass::CacheStores::Memory.new
+        @backing_store ||= compiler_opts[:cache_store]
+        @backing_store ||= Sass::CacheStores::Filesystem.new(determine_cache_location)
+        @cache_store ||= Sass::CacheStores::Chain.new(@memory_store, @backing_store)
+        @memory_store.reset!
+
+        Compass::Compiler.new(
+          working_path,
+          Compass.configuration.sass_path,
+          Compass.configuration.css_path,
+          @compiler_opts.merge(:cache_store => @cache_store).merge(additional_options)
+        )
+      end
+
+      def explicit_sass_files
+        return unless options[:sass_files]
+        options[:sass_files].map do |sass_file|
+          if absolute_path? sass_file
+            sass_file
+          else
+            File.join(Dir.pwd, sass_file)
+          end
+        end
+      end
+
+      def determine_cache_location
+        Compass.configuration.cache_path || Sass::Plugin.options[:cache_location] || File.join(working_path, ".sass-cache")
+      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[:sass_files] = arguments.dup
+              parser.options[:force] = true
+            end
+          end
+        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,170 @@
+require 'fileutils'
+require 'pathname'
+require 'compass/commands/base'
+require 'compass/commands/update_project'
+require 'sass/plugin'
+
+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
+    module MemoryDebugger
+      def report_on_instances(type, options = {})
+        @@runs ||= 0
+        @@runs += 1
+        @@object_id_tracker ||= {}
+        @@object_id_tracker[type] ||= []
+        GC.start
+        sleep options.fetch(:gc_pause, 1)
+        count = ObjectSpace.each_object(type) do |obj|
+          if options.fetch(:verbose, true)
+            if @@runs > 2
+              if !@@object_id_tracker[type].include?(obj.object_id)
+                begin
+                  puts obj.inspect
+                rescue
+                end
+                puts "#{obj.class.name}:#{obj.object_id}"
+              end
+            end
+            @@object_id_tracker[type] << obj.object_id
+          end
+        end
+        puts "#{type}: #{count} instances."
+      end
+    end
+    class WatchProject < UpdateProject
+
+      register :watch
+
+      attr_accessor :last_update_time, :last_sass_files
+
+      include MemoryDebugger
+
+      def perform
+        Signal.trap("INT") do
+          puts ""
+          exit 0
+        end
+
+        check_for_sass_files!(new_compiler_instance)
+        recompile
+
+        require 'fssm'
+
+
+        if options[:poll]
+          require "fssm/backends/polling"
+          # have to silence the ruby warning about chaning a constant.
+          stderr, $stderr = $stderr, StringIO.new
+          FSSM::Backends.const_set("Default", FSSM::Backends::Polling)
+          $stderr = stderr
+        end
+
+        action = FSSM::Backends::Default.to_s == "FSSM::Backends::Polling" ? "polling" : "watching"
+
+        puts ">>> Compass is #{action} for changes. Press Ctrl-C to Stop."
+        $stdout.flush
+
+        begin
+        FSSM.monitor do |monitor|
+          Compass.configuration.sass_load_paths.each do |load_path|
+            load_path = load_path.root if load_path.respond_to?(:root)
+            next unless load_path.is_a? String
+            monitor.path load_path do |path|
+              path.glob '**/*.s[ac]ss'
+
+              path.update &method(:recompile)
+              path.delete {|base, relative| remove_obsolete_css(base,relative); recompile(base, relative)}
+              path.create &method(:recompile)
+            end
+          end
+          Compass.configuration.watches.each do |glob, callback|
+            monitor.path Compass.configuration.project_path do |path|
+              path.glob glob
+              path.update do |base, relative|
+                puts ">>> Change detected to: #{relative}"
+                $stdout.flush
+                callback.call(base, relative)
+              end
+              path.create do |base, relative|
+                puts ">>> New file detected: #{relative}"
+                $stdout.flush
+                callback.call(base, relative)
+              end
+              path.delete do |base, relative|
+                puts ">>> File Removed: #{relative}"
+                $stdout.flush
+                callback.call(base, relative)
+              end
+            end
+          end
+
+        end
+      rescue FSSM::CallbackError => e
+        # FSSM catches exit? WTF.
+        if e.message =~ /exit/
+          exit
+        end
+      end
+      end
+
+      def remove_obsolete_css(base = nil, relative = nil)
+        compiler = new_compiler_instance(:quiet => true)
+        sass_files = compiler.sass_files
+        deleted_sass_files = (last_sass_files || []) - sass_files
+        deleted_sass_files.each do |deleted_sass_file|
+          css_file = compiler.corresponding_css_file(deleted_sass_file)
+          remove(css_file) if File.exists?(css_file)
+        end
+        self.last_sass_files = sass_files
+      end
+
+      def recompile(base = nil, relative = nil)
+        @memory_cache.reset! if @memory_cache
+        compiler = new_compiler_instance(:quiet => true, :loud => [:identical, :overwrite, :create])
+        if file = compiler.out_of_date?
+          begin
+            puts ">>> Change detected at "+Time.now.strftime("%T")+" to: #{relative || compiler.relative_stylesheet_name(file)}"
+            $stdout.flush
+            compiler.run
+            GC.start
+          rescue StandardError => e
+            ::Compass::Exec::Helpers.report_error(e, options)
+          end
+        end
+      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