compass-edge 0.9.1

data/lib/compass/validator.rb

@@ -0,0 +1,10 @@
+begin
+  require 'rubygems'
+  require 'compass-validator'
+rescue LoadError
+  puts %Q{The Compass CSS Validator could not be loaded. Please install it:
+
+sudo gem install chriseppstein-compass-validator --source http://gems.github.com/
+}
+  exit(1)
+end

data/lib/compass/version.rb

@@ -0,0 +1,57 @@
+module Compass
+  module Version
+    # Returns a hash representing the version.
+    # The :major, :minor, and :teeny keys have their respective numbers.
+    # The :string key contains a human-readable string representation of the version.
+    # The :rev key will have the current revision hash.
+    #
+    # This method swiped from Haml and then modified, some credit goes to Nathan Weizenbaum
+    attr_writer :version
+    def version
+      return @version if defined?(@version)
+
+      read_version_file
+
+      if r = revision
+        @version[:rev] = r
+        @version[:string] << " [#{r[0...7]}]"
+      end
+
+      @version
+    end
+
+    protected
+
+    def scope(file) # :nodoc:
+      File.join(File.dirname(__FILE__), '..', '..', file)
+    end
+
+    def read_version_file
+      require 'yaml'
+      @version = YAML::load(File.read(scope('VERSION.yml')))
+      @version[:string] = "#{@version[:major]}.#{@version[:minor]}.#{@version[:patch]}"
+      @version[:teeny] = @version[:patch]
+    end
+
+    def revision
+      revision_from_git || revision_from_file
+    end
+
+    def revision_from_file
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        rev if rev =~ /[a-f0-9]+/
+      end
+    end
+
+    def revision_from_git
+      if File.exists?(scope('.git/HEAD'))
+        rev = File.read(scope('.git/HEAD')).strip
+        if rev =~ /^ref: (.*)$/
+          rev = File.read(scope(".git/#{$1}")).strip
+        end
+      end
+    end
+
+  end
+end

data/lib/vendor/fssm.rb

@@ -0,0 +1,28 @@
+module FSSM
+  FileNotFoundError = Class.new(StandardError)
+  CallbackError = Class.new(StandardError)
+  
+  class << self
+    def monitor(*args, &block)
+      monitor = FSSM::Monitor.new
+      context = args.empty? ? monitor : monitor.path(*args)
+      if block && block.arity == 0
+        context.instance_eval(&block)
+      elsif block && block.arity == 1
+        block.call(context)
+      end
+      monitor.run
+    end
+  end
+end
+
+require 'pathname'
+require 'fssm/ext'
+require 'fssm/support'
+require 'fssm/path'
+require 'fssm/state'
+require 'fssm/monitor'
+
+require "fssm/backends/#{FSSM::Support.backend.downcase}"
+FSSM::Backends::Default = FSSM::Backends.const_get(FSSM::Support.backend)
+

data/lib/vendor/fssm/backends/fsevents.rb

@@ -0,0 +1,78 @@
+module FSSM::Backends
+  class FSEvents    
+    def initialize(options={})
+      @streams   = []
+      @handlers  = {}
+      @allocator = options[:allocator] || OSX::KCFAllocatorDefault
+      @context   = options[:context]   || nil
+      @since     = options[:since]     || OSX::KFSEventStreamEventIdSinceNow
+      @latency   = options[:latency]   || 0.0
+      @flags     = options[:flags]     || 0
+    end
+    
+    def add_path(path, preload=true)
+      @handlers["#{path}"] = FSSM::State.new(path, preload)
+      
+      cb = lambda do |stream, context, number, paths, flags, ids|
+        paths.regard_as('*')
+        watched = OSX.FSEventStreamCopyPathsBeingWatched(stream).first
+        @handlers["#{watched}"].refresh
+        # TODO: support this level of granularity
+        # number.times do |n|
+        #   @handlers["#{watched}"].refresh_path(paths[n])
+        # end
+      end
+      
+      @streams << create_stream(cb, "#{path}")
+    end
+    
+    def run
+      @streams.each do |stream|
+        schedule_stream(stream)
+        start_stream(stream)
+      end
+      
+      begin
+        OSX.CFRunLoopRun
+      rescue Interrupt
+        @streams.each do |stream|
+          stop_stream(stream)
+          invalidate_stream(stream)
+          release_stream(stream)
+        end
+      end
+      
+    end
+    
+    private
+    
+    def create_stream(callback, paths)
+      paths = [paths] unless paths.is_a?(Array)
+      OSX.FSEventStreamCreate(@allocator, callback, @context, paths, @since, @latency, @flags)
+    end
+    
+    def schedule_stream(stream, options={})
+      run_loop  = options[:run_loop]  || OSX.CFRunLoopGetCurrent
+      loop_mode = options[:loop_mode] || OSX::KCFRunLoopDefaultMode
+      
+      OSX.FSEventStreamScheduleWithRunLoop(stream, run_loop, loop_mode)
+    end
+    
+    def start_stream(stream)
+      OSX.FSEventStreamStart(stream)
+    end
+    
+    def stop_stream(stream)
+      OSX.FSEventStreamStop(stream)
+    end
+    
+    def invalidate_stream(stream)
+      OSX.FSEventStreamInvalidate(stream)
+    end
+    
+    def release_stream(stream)
+      OSX.FSEventStreamRelease(stream)
+    end
+    
+  end
+end

data/lib/vendor/fssm/backends/polling.rb

@@ -0,0 +1,24 @@
+module FSSM::Backends
+  class Polling
+  def initialize(options={})
+    @handlers  = []
+    @latency   = options[:latency]   || 1
+  end
+  
+  def add_path(path, preload=true)
+    @handlers << FSSM::State.new(path, preload)
+  end
+  
+  def run
+    begin
+      loop do
+        start = Time.now.to_f
+        @handlers.each {|handler| handler.refresh}
+        nap_time = @latency - (Time.now.to_f - start)
+        sleep nap_time if nap_time > 0
+      end
+    rescue Interrupt
+    end
+  end
+end
+end

data/lib/vendor/fssm/ext.rb

@@ -0,0 +1,7 @@
+class Pathname
+  class << self
+    def for(path)
+      path.is_a?(Pathname) ? path : new(path)
+    end
+  end
+end

data/lib/vendor/fssm/monitor.rb

@@ -0,0 +1,21 @@
+class FSSM::Monitor
+  def initialize(options={})
+    @options = options
+    @backend = FSSM::Backends::Default.new
+  end
+  
+  def path(*args, &block)
+    path = FSSM::Path.new(*args)
+    if block && block.arity == 0
+      path.instance_eval(&block)
+    elsif block && block.arity == 1
+      block.call(path)
+    end
+    @backend.add_path(path)
+    path
+  end
+  
+  def run
+    @backend.run
+  end
+end

data/lib/vendor/fssm/path.rb

@@ -0,0 +1,88 @@
+class FSSM::Path
+  def initialize(path=nil, glob=nil, &block)
+    set_path(path || '.')
+    set_glob(glob || '**/*')
+    init_callbacks
+    if block && block.arity == 0
+      self.instance_eval(&block)
+    elsif block && block.arity == 1
+      block.call(self)
+    end
+  end
+  
+  def to_s
+    @path.to_s
+  end
+  
+  def to_pathname
+    @path
+  end
+  
+  def glob(value=nil)
+    return @glob if value.nil?
+    set_glob(value)
+  end
+  
+  def create(callback_or_path=nil, &block)
+    callback_action(:create, (block_given? ? block : callback_or_path))
+  end
+  
+  def update(callback_or_path=nil, &block)
+    callback_action(:update, (block_given? ? block : callback_or_path))
+  end
+  
+  def delete(callback_or_path=nil, &block)
+    callback_action(:delete, (block_given? ? block : callback_or_path))
+  end
+  
+  private
+  
+  def init_callbacks
+    do_nothing = lambda {|base, relative|}
+    @callbacks = Hash.new(do_nothing)
+  end
+  
+  def callback_action(type, arg=nil)
+    if arg.is_a?(Proc)
+      set_callback(type, arg)
+    elsif arg.nil?
+      get_callback(type)
+    else
+      run_callback(type, arg)
+    end
+  end
+  
+  def set_callback(type, arg)
+    raise ArgumentError, "Proc expected" unless arg.is_a?(Proc)
+    @callbacks[type] = arg
+  end
+  
+  def get_callback(type)
+    @callbacks[type]
+  end
+  
+  def run_callback(type, arg)
+    base, relative = split_path(arg)
+    
+    begin
+      @callbacks[type].call(base, relative)
+    rescue Exception => e
+      raise FSSM::CallbackError, "#{type} - #{base.join(relative)}: #{e.message}", e.backtrace
+    end
+  end
+  
+  def split_path(path)
+    path = Pathname.for(path)
+    [@path, (path.relative? ? path : path.relative_path_from(@path))] 
+  end
+  
+  def set_path(path)
+    path = Pathname.for(path)
+    raise FSSM::FileNotFoundError, "#{path}" unless path.exist?
+    @path = path.realpath
+  end
+  
+  def set_glob(glob)
+    @glob = glob.is_a?(Array) ? glob : [glob]
+  end
+end

data/lib/vendor/fssm/state.rb

@@ -0,0 +1,46 @@
+class FSSM::State
+  def initialize(path, preload=true)
+    @path = path
+    @snapshot = {}
+    snapshot if preload
+  end
+  
+  def refresh
+    previous = @snapshot
+    current = snapshot
+    
+    deleted(previous, current)
+    created(previous, current)
+    modified(previous, current)    
+  end
+  
+  private
+  
+  def created(previous, current)
+    (current.keys - previous.keys).each {|created| @path.create(created)}
+  end
+  
+  def deleted(previous, current)
+    (previous.keys - current.keys).each {|deleted| @path.delete(deleted)}
+  end
+  
+  def modified(previous, current)
+    (current.keys & previous.keys).each do |file|
+      @path.update(file) if (current[file] <=> previous[file]) != 0
+    end
+  end
+  
+  def snapshot
+    snap = {}
+    @path.glob.each {|glob| add_glob(snap, glob)}
+    @snapshot = snap
+  end
+  
+  def add_glob(snap, glob)
+    Pathname.glob(@path.to_pathname.join(glob)).each do |fn|
+      next unless fn.file?
+      snap["#{fn}"] = fn.mtime
+    end
+  end
+  
+end

data/lib/vendor/fssm/support.rb

@@ -0,0 +1,26 @@
+module FSSM::Support
+  class << self
+    # def backend
+    #   (mac? && carbon_core?) ? 'FSEvents' : 'Polling'
+    # end
+    
+    def backend
+      'Polling'
+    end
+    
+    def mac?
+      @@mac ||= RUBY_PLATFORM =~ /darwin/i
+    end
+    
+    def carbon_core?
+      @@carbon_core ||= begin
+        require 'osx/foundation'
+        OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+        true
+      rescue LoadError
+        false
+      end
+    end
+
+  end
+end

data/test/command_line_helper.rb

@@ -0,0 +1,97 @@
+module Compass::CommandLineHelper
+  def compass(*arguments)
+    options = arguments.last.is_a?(Hash) ? arguments.pop : {}
+    options[:wait] = 0.25
+    if block_given?
+      responder = Responder.new
+      yield responder
+      IO.popen("-", "w+") do |io|
+        if io
+          #parent process
+          output = ""
+          eof_at = nil
+          while !eof_at || (Time.now - eof_at < options[:wait])
+            if io.eof?
+              eof_at ||= Time.now
+              sleep 0.1
+            else
+              eof_at = nil
+              timeout(1) do
+                partial_output = io.readpartial(1024)
+                # puts "))))#{partial_output}((((("
+                output << partial_output
+              end
+              prompt = output.split("\n").last.strip
+              if response = responder.response_for(prompt)
+                io.puts response
+              end
+            end
+          end
+          responder.assert_required_responses!
+          @last_result = output
+        else
+          #child process
+          execute *arguments
+        end
+      end
+    else
+      @last_result = capture_output do
+        execute *arguments
+      end
+    end
+  rescue Timeout::Error
+    fail "Read from child process timed out"
+  end
+
+  class Responder
+    Response = Struct.new(:prompt, :text, :required, :responded)
+    def initialize
+      @responses = []
+    end
+    def respond_to(prompt, options = {})
+      @responses << Response.new(prompt, options[:with], options[:required])
+    end
+    def response_for(prompt)
+      response = @responses.detect{|r| r.prompt == prompt}
+      if response
+        response.responded = true
+        response.text
+      end
+    end
+    def assert_required_responses!
+      @responses.each do |response|
+        if response.required && !response.responded
+          raise "Prompt not encountered: \"#{response.prompt}\""
+        end
+      end
+    end
+  end
+
+  def assert_action_performed(action, path)
+    actions_found = []
+    @last_result.split("\n").each do |line|
+      line = line.split
+      return if line.first == action.to_s && line.last == path
+      actions_found << line.first if line.last == path
+    end
+    message = "Action #{action.inspect} was not performed on: #{path}."
+    message += "The following actions were performed: #{actions_found.join(", ")}" if actions_found.any?
+    puts @last_result
+    fail message
+  end
+
+  def within_tmp_directory(dir = "tmp")
+    d = absolutize(dir)
+    FileUtils.mkdir_p(d)
+    Dir.chdir(d) do
+      yield
+    end
+  ensure
+    FileUtils.rm_rf(d)
+  end
+
+  def execute(*arguments)
+    command_line_class = Compass::Exec::Helpers.select_appropriate_command_line_ui(arguments)
+    command_line_class.new(arguments).run!
+  end
+end