compass 1.0.0.alpha.21 → 1.0.0.rc.0

data/RELEASE_VERSION

@@ -1 +0,0 @@
-1.0.0.alpha.21

data/VERSION

@@ -1 +0,0 @@
-1.0.0.alpha.20

data/lib/compass/watcher.rb

@@ -1,11 +0,0 @@
-require 'compass/watcher/watch'
-require 'compass/watcher/compiler'
-require 'compass/watcher/project_watcher'
-
-module Compass
-  module Watcher
-    class WatcherException < Compass::Error; end
-    class NoCallbackError < WatcherException; end
-    class AbsolutePathError < WatcherException; end
-  end
-end

data/lib/compass/watcher/compiler.rb

@@ -1,60 +0,0 @@
-module Compass
-  module Watcher
-   class Compiler
-      include Compass::Actions
-      attr_reader :working_path, :memory_store, :backing_store, :cache_store, :compiler_options, :compiler
-
-      def initialize(working_path, additional_options={})
-        @working_path       = working_path
-        @compiler_options   = create_compiler_options(additional_options)
-        @memory_store     ||= Sass::CacheStores::Memory.new
-        @backing_store    ||= compiler_options[:cache_store]
-        @backing_store    ||= Sass::CacheStores::Filesystem.new(determine_cache_location)
-        @cache_store      ||= Sass::CacheStores::Chain.new(@memory_store, @backing_store)
-        @compiler         ||= create_compiler
-      end
-
-      def compile
-        @memory_cache.reset! if @memory_cache
-        compiler.reset!
-        if file = compiler.out_of_date?
-          begin
-            time = Time.now.strftime("%T")
-            log_action(:info, "Change detected at #{time} to: #{compiler.relative_stylesheet_name(file)}", compiler_options)
-            compiler.run
-            GC.start
-          rescue StandardError => e
-            ::Compass::Exec::Helpers.report_error(e, compiler_options)
-          end
-        end
-      end
-
-    private #=========================================================================================>
-
-      def create_compiler_options(additional_options)
-        compiler_opts = {:sass => Compass.sass_engine_options, :cache_store => @cache_store, :quiet => true, :loud => [:identical, :overwrite, :create]}.merge(additional_options)
-        compiler_opts[:cache_location] ||= determine_cache_location
-        compiler_opts[:sourcemap] = Compass.configuration.sourcemap if compiler_opts[:sourcemap].nil?
-        if compiler_opts.include?(:debug_info)
-          compiler_opts[:sass][:debug_info] = compiler_opts.delete(:debug_info)
-        end
-        
-        compiler_opts
-      end
-
-      def create_compiler
-        @memory_store.reset!
-        Compass::Compiler.new(
-          working_path,
-          Compass.configuration.sass_path,
-          Compass.configuration.css_path,
-          compiler_options.dup
-        )
-      end
-
-      def determine_cache_location
-        Compass.configuration.cache_path || Sass::Plugin.options[:cache_location] || File.join(working_path, ".sass-cache")
-      end
-    end
-  end
-end

data/lib/compass/watcher/project_watcher.rb

@@ -1,179 +0,0 @@
-require 'forwardable'
-module Compass
-  module Watcher
-    class ProjectWatcher
-      include Compass::Actions
-      SASS_FILTER = '*.s[ac]ss'
-      ALL_CHILDREN_SASS_FILTER = File.join('**', SASS_FILTER)
-      POLLING_MESSAGE = 'Compass is polling for changes'
-
-      attr_reader :options, :project_path, :watcher_compiler, :listener, :poll, :css_dir, :watchers
-
-      alias :working_path :project_path
-
-      extend Forwardable
-  
-      def_delegators :@watcher_compiler, :compiler, :compiler
-      def_delegators :@watcher_compiler, :compile, :compile
-
-      def initialize(project_path, watches=[], options={}, poll=false)
-        @poll             = poll
-        @options          = options
-        @project_path     = project_path
-        @css_dir          = Compass.configuration.css_dir
-        @watchers         = [SassWatch.new(&method(:sass_callback))] + watches
-        @watcher_compiler = Compass::Watcher::Compiler.new(project_path, options)
-        setup_listener
-      end
-
-      def watch!
-        if Sass::Util.listen_geq_2?
-          @listeners.each {|l| l.start}
-          sleep
-        else
-          listener.start!
-        end
-      rescue Interrupt
-        if Sass::Util.listen_geq_2?
-          Listen.stop
-        else
-          listener.stop
-        end
-        logger.log "\nHappy Styling!"
-      end
-
-      def listeners
-        @listeners || [@listener]
-      end
-
-    private #============================================================================>
-
-      def setup_listener
-        Sass::Util.load_listen!
-        listen_opts = {:relative_paths => false}
-
-        if Sass::Util.listen_geq_2?
-          listen_opts.update(:force_polling => true) if poll
-          listen_opts.update(:polling_fallback_message => POLLING_MESSAGE,
-                             :ignore => /\.css$/)
-          @listeners = []
-          directories_to_watch.each do |dir|
-            # work around https://github.com/guard/listen/issues/243
-            @listeners << Listen.to(dir, listen_opts, &method(:listen_callback))
-          end
-        else
-          args = directories_to_watch + [listen_opts]
-          @listener = Listen::Listener.new(*args, &method(:listen_callback))
-          @listener = listener.force_polling(true) if poll
-          @listener = listener.polling_fallback_message(POLLING_MESSAGE)
-          @listener.ignore(/\.css$/)
-        end
-
-        @listener
-      end
-
-      def directories_to_watch
-        @directories_to_watch ||= begin
-                                    dirs = [Compass.configuration.sass_path] +
-                                      Compass.configuration.sass_load_paths.map{|p| p.directories_to_watch}
-                                    dirs.flatten!
-                                    dirs.compact!
-                                    dirs.select {|d| File.writable?(d) }
-                                    dirs.uniq!
-                                    dirs
-                                  end
-      end
-
-      def listen_callback(modified_files, added_files, removed_files)
-        # log_action(:info, ">>> Listen Callback fired added: #{added_files}, mod: #{modified_files}, rem: #{removed_files}", {})
-        files = {:modified => modified_files,
-                 :added    => added_files,
-                 :removed  => removed_files}
-
-        run_once, run_each = watchers.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 sass_callback(base, file, action)
-        #log_action(:info, ">>> Sass Callback fired #{action}, #{file}", {})
-        full_filename = File.expand_path(File.join(base,file))
-        case action
-        when :modified
-          sass_modified(full_filename)
-        when :added
-          sass_added(full_filename)
-        when :removed
-          sass_removed(full_filename)
-        else
-          raise ArgumentError, "Illegal Action: #{action.inspect}"
-        end
-      end
-
-      def sass_modified(file)
-        log_action(:info, "#{filename_for_display(file)} was modified", options)
-        compile
-      end
-
-      def sass_added(file)
-        log_action(:info, "#{filename_for_display(file)} was added", options)
-        compile
-      end
-
-      def sass_removed(file)
-        log_action(:info, "#{filename_for_display(file)} was removed", options)
-        css_file = compiler.corresponding_css_file(file)
-        sourcemap_file = compiler.corresponding_sourcemap_file(file)
-        compile
-        remove(css_file) if File.exists?(css_file)
-        remove(sourcemap_file) if File.exists?(sourcemap_file)
-      end
-
-      def local_development_locations
-        @local_development_locations ||= begin
-                                          r = [Compass.configuration.sass_path] + Array(Compass.configuration.additional_import_paths)
-                                          r.map!{|l| File.expand_path(l) }
-                                         end
-      end
-
-      def filename_for_display(f)
-        if framework = Frameworks::ALL.detect {|fmwk| in_directory?(fmwk.stylesheets_directory, f) }
-          "(#{framework.name}) #{relative_to(f, framework.stylesheets_directory)}"
-        elsif directories_to_watch.detect{|d| in_directory?(d, f) }
-          relative_to_working_directory(f)
-        else
-          f
-        end
-      end
-
-      def in_directory?(dir, f)
-        dir && (f[0...(dir.size)] == dir)
-      end
-
-      def relative_to_working_directory(f)
-        relative_to(f, Dir.pwd)
-      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
-    end
-  end
-end

data/lib/compass/watcher/watch.rb

@@ -1,51 +0,0 @@
-module Compass
-  module Watcher
-    class BasicWatch
-      attr_reader :callback
-
-      def initialize(&block)
-        unless block
-          raise NoCallbackError, "A Block must be supplied in order to be watched"
-        end
-        @callback = block
-      end
-
-      def run_callback(base, relative, action)
-        callback.call(base, relative, action)
-      end
-
-      def run_once_per_changeset?
-        false
-      end
-
-      def match?(path)
-        Sass::Util.abstract(self)
-      end
-    end
-
-    class Watch < BasicWatch
-      attr_reader :glob
-
-      def initialize(glob, &block)
-        super(&block)
-        unless glob
-          raise WatcherException, "A glob must be supplied in order to be watched"
-        end
-        @glob = glob
-      end
-
-      def match?(changed_path)
-        File.fnmatch(glob, changed_path)
-      end
-    end
-
-    class SassWatch < BasicWatch
-      def match?(path)
-        path =~ /s[ac]ss$/
-      end
-      def run_once_per_changeset?
-        true
-      end
-    end
-  end
-end

data/test/fixtures/stylesheets/valid/css/another_simple.css

@@ -1,4 +0,0 @@
-/* line 1, ../sass/another_simple.scss */
-.another-simple-class {
-  color: blue;
-}

data/test/fixtures/stylesheets/valid/css/simple.css

@@ -1,4 +0,0 @@
-/* line 1, ../sass/simple.sass */
-div {
-  color: red;
-}

data/test/units/watcher/compiler_test.rb

@@ -1,39 +0,0 @@
-require 'test_helper'
-require 'compass'
-
-class WatcherCompilerTest < Test::Unit::TestCase
-
-  def setup
-    @working_path = File.join(fixture_path, 'stylesheets', 'valid')
-    @to = File.join(@working_path, 'css')
-    remove_to
-    Compass.add_configuration({:sass_path => File.join(@working_path, 'sass'), :css_path => @to }, 'test')
-  end
-
-  test "it sould create a new instance of a compass compiler" do
-    watch_compiler = Compass::Watcher::Compiler.new(@working_path, {})
-    assert watch_compiler.compiler.is_a?(Compass::Compiler)
-  end
-
-  test "debug info gets passed into sass options" do
-    watch_compiler = Compass::Watcher::Compiler.new(@working_path, {:debug_info => true})
-    assert watch_compiler.compiler_options[:sass][:debug_info]
-  end
-  
-  test "should run compiler" do
-    watch_compiler = Compass::Watcher::Compiler.new(@working_path, {})
-    watch_compiler.compiler.expects(:reset_staleness_checker!).once
-    watch_compiler.compiler.expects(:run).once
-    watch_compiler.expects(:log_action).once
-    watch_compiler.compile
-  end
-
-  def remove_to
-    ::FileUtils.rm_r @to if File.exists?(@to)
-  end
-
-  def teardown
-    remove_to
-  end
-
-end

data/test/units/watcher/project_watcher_test.rb

@@ -1,85 +0,0 @@
-require 'test_helper'
-require 'compass'
-
-class ProjectWatcherTest < Test::Unit::TestCase
-
-  def setup
-    @working_path = File.join(fixture_path, 'stylesheets', 'valid')
-    @to = File.join(@working_path, 'css')
-    remove_to
-    Compass.add_configuration({:sass_path => File.join(@working_path, 'sass'), :css_path => @to }, 'test')
-    @project_watcher = Compass::Watcher::ProjectWatcher.new(@working_path)
-  end
-
-  def fullpath(basename)
-    File.join(@working_path, basename)
-  end
-
-  def foo_basename
-    "foo.scss"
-  end
-
-  def sample_basename
-    File.join('sass', 'sample.scss')
-  end
-
-  test "should initalize correctly" do
-    if Sass::Util.listen_geq_2?
-      assert @project_watcher.listeners.is_a?(Array) && @project_watcher.listeners.size > 0
-    else
-      assert @project_watcher.listener.is_a?(Listen::Listener)
-    end
-    assert_equal 1, @project_watcher.watchers.size
-  end
-
-  test "should have 3 watchers" do
-    Dir.chdir File.join(@working_path, 'sass') do
-      @project_watcher = Compass::Watcher::ProjectWatcher.new(Dir.pwd)
-      assert_equal 1, @project_watcher.watchers.size
-    end
-  end
-
-  test "compiler" do
-    assert @project_watcher.compiler.is_a?(Compass::Compiler)
-  end
-
-  test "sass callback add" do
-    @project_watcher.expects(:sass_added).with(fullpath(foo_basename)).once
-    @project_watcher.send(:sass_callback, @working_path, foo_basename, :added)
-  end
-
-  test "sass callback modified" do
-    @project_watcher.expects(:sass_modified).with(fullpath(foo_basename)).once
-    @project_watcher.send(:sass_callback, @working_path, foo_basename, :modified)
-  end
-
-  test "sass callback removed" do
-    @project_watcher.expects(:sass_removed).with(fullpath(foo_basename)).once
-    @project_watcher.send(:sass_callback, @working_path, foo_basename, :removed)
-  end
-
-  test "listen callback modified" do
-    @project_watcher.expects(:sass_modified).with(fullpath(sample_basename)).once
-    @project_watcher.send(:listen_callback, sample_basename, [], [])
-  end
-
-  test "listen callback added" do
-    @project_watcher.expects(:sass_added).with(fullpath(sample_basename)).once
-    @project_watcher.send(:listen_callback, [], sample_basename, [])
-  end
-
-  test "listen callback removed" do
-    @project_watcher.expects(:sass_removed).with(fullpath(sample_basename)).once
-    @project_watcher.send(:listen_callback, [], [], sample_basename)
-  end
-
-  def remove_to
-    ::FileUtils.rm_r @to if File.exists?(@to)
-  end
-
-  def teardown
-    remove_to
-  end
-
-
-end