compass-edge 0.9.5.0 → 0.10.0.pre

data/lib/compass/sass_extensions/functions/color_stop.rb

@@ -1,10 +0,0 @@
-module Compass::SassExtensions::Functions::ColorStop
-  def color_stop(*args)
-    raise Sass::SyntaxError, "An even number of arguments must be passed to color-stop()" unless args.size % 2 == 0
-    stops = []
-    while args.size > 0
-      stops << "color-stop(#{args.shift}, #{args.shift})"
-    end
-    Sass::Script::String.new(stops.join(", "))
-  end
-end

data/lib/compass/sass_extensions/functions/font_files.rb

@@ -1,11 +0,0 @@
-module Compass::SassExtensions::Functions::FontFiles
-  def font_files(*args)
-    raise Sass::SyntaxError, "An even number of arguments must be passed to font_files()" unless args.size % 2 == 0
-    files = []
-    while args.size > 0
-      files << "#{font_url(args.shift)} format('#{args.shift}')"
-    end
-    Sass::Script::String.new(files.join(", "))
-  end
-
-end

data/lib/compass/sass_extensions/monkey_patches/traversal.rb

@@ -1,23 +0,0 @@
-module Sass
-  module Tree
-    class Node
-      unless method_defined?(:visit_depth_first)
-        def visit_depth_first(visitor)
-          visitor.visit(self)
-          visitor.down(self) if children.any? and visitor.respond_to?(:down)
-          if is_a?(ImportNode) && visitor.import?(self)
-            root = Sass::Files.tree_for(import, @options)
-            imported_children = root.children
-          end
-
-          (imported_children || children).each do |child|
-            break if visitor.respond_to?(:stop?) && visitor.stop?
-            child.visit_depth_first(visitor)
-          end
-          visitor.up(self) if children.any?
-        end
-      end
-    end
-  end
-end
-

data/lib/compass/stats.rb

@@ -1,92 +0,0 @@
-module Compass
-  module Stats
-    class StatsVisitor
-      attr_accessor :rule_count, :prop_count, :mixin_def_count, :mixin_count
-      def initialize
-        self.rule_count = 0
-        self.prop_count = 0
-        self.mixin_def_count = 0
-        self.mixin_count = 0
-      end
-      def visit(node)
-        self.prop_count += 1 if node.is_a?(Sass::Tree::PropNode) && !node.children.any?
-        if node.is_a?(Sass::Tree::RuleNode)
-          self.rule_count += node.rules.map{|r| r.split(/,/)}.flatten.compact.size
-        end
-        self.mixin_def_count += 1 if node.is_a?(Sass::Tree::MixinDefNode)
-        self.mixin_count += 1 if node.is_a?(Sass::Tree::MixinNode)
-      end
-      def up(node)
-      end
-      def down(node)
-      end
-      def import?(node)
-        return false
-        full_filename = node.send(:import)
-        full_filename != Compass.deprojectize(full_filename)
-      end
-    end
-    class CssFile
-      attr_accessor :path, :css
-      attr_accessor :selector_count, :prop_count
-      def initialize(path)
-        require 'css_parser'
-        self.path = path
-        self.css = CssParser::Parser.new
-        self.css.add_block!(contents)
-        self.selector_count = 0
-        self.prop_count = 0
-      end
-      def contents
-        @contents ||= File.read(path)
-      end
-      def lines
-        contents.inject(0){|m,c| m + 1 }
-      end
-      def analyze!
-        css.each_selector do |selector, declarations, specificity|
-          sels = selector.split(/,/).size
-          props = declarations.split(/;/).size
-          self.selector_count += sels
-          self.prop_count += props
-        end
-      end
-    end
-    class SassFile
-      attr_accessor :path
-      attr_reader :visitor
-      def initialize(path)
-        self.path = path
-      end
-      def contents
-        @contents ||= File.read(path)
-      end
-      def tree
-        @tree = Sass::Engine.new(contents, Compass.configuration.to_sass_engine_options).to_tree
-      end
-      def visit_tree!
-        @visitor = StatsVisitor.new
-        tree.visit_depth_first(@visitor)
-        @visitor
-      end
-      def analyze!
-        visit_tree!
-      end
-      def lines
-        contents.inject(0){|m,c| m + 1 }
-      end
-      def rule_count
-        visitor.rule_count
-      end
-      def prop_count
-        visitor.prop_count
-      end
-      def mixin_def_count
-        visitor.mixin_def_count
-      end
-      def mixin_count
-        visitor.mixin_count
-      end
-    end
-  end
-end

data/lib/vendor/fssm/cache.rb

@@ -1,193 +0,0 @@
-class FSSM::Cache
-  module Common
-    include Enumerable
-
-    def initialize
-      @children = Hash.new
-    end
-
-    def each(prefix='./', &block)
-      @children.each do |segment, node|
-        cprefix = Pathname.for(prefix.dup).join(segment)
-        block.call(cprefix, node)
-        node.each(cprefix, &block)
-      end
-    end
-
-    protected
-    
-    def with_lock
-      @mutex.lock
-      yield
-      @mutex.unlock
-    end
-    
-    def descendant(path)
-      recurse_on_key(path, false)
-    end
-
-    def descendant!(path)
-      recurse_on_key(path, true)
-    end
-
-    def child(segment)
-      has_child?(segment) ? @children["#{segment}"] : nil
-    end
-
-    def child!(segment)
-      (@children["#{segment}"] ||= Node.new)
-    end
-
-    def has_child?(segment)
-      @children.include?("#{segment}")
-    end
-
-    def remove_child(segment)
-      @children.delete("#{segment}")
-    end
-
-    def remove_children
-      @children.clear
-    end
-
-    def recurse_on_key(key, create)
-      key = sanitize_key(key)
-      node = self
-
-      until key.empty?
-        segment = key.shift
-        node = create ? node.child!(segment) : node.child(segment)
-        return nil unless node
-      end
-
-      node
-    end
-
-    def key_for_path(path)
-      Pathname.for(path).names
-    end
-
-    def relative_path(path)
-      sanitize_path(path, false)
-    end
-
-    def absolute_path(path)
-      sanitize_path(path, true)
-    end
-
-    def sanitize_path(path, absolute)
-      if path.is_a?(Array)
-        first = absolute ? '/' : path.shift
-        path = path.inject(Pathname.new("#{first}")) do |pathname, segment|
-          pathname.join("#{segment}")
-        end
-        path
-      else
-        path = Pathname.for(path)
-        absolute ? path.expand_path : path
-      end
-    end
-  end
-
-  class Node
-    include Common
-    
-    attr_accessor :mtime
-    attr_accessor :ftype
-
-    def <=>(other)
-      self.mtime <=> other.mtime
-    end
-
-    def from_path(path)
-      path = absolute_path(path)
-      @mtime = path.mtime
-      @ftype = path.ftype
-    end
-
-    protected
-
-    def sanitize_key(key)
-      key_for_path(relative_path(key))
-    end
-  end
-
-  include Common
-  
-  def initialize
-    @mutex = Mutex.new
-    super
-  end
-
-  def clear
-    @mutex.lock
-    @children.clear
-    @mutex.unlock
-  end
-
-  def set(path)
-    unset(path)
-    node = descendant!(path)
-    node.from_path(path)
-    node.mtime
-  end
-
-  def unset(path='/')    
-    key = sanitize_key(path)
-
-    if key.empty?
-      self.clear
-      return nil
-    end
-    
-    segment = key.pop
-    node = descendant(key)
-
-    return unless node
-    
-    @mutex.lock
-    node.remove_child(segment)
-    @mutex.unlock    
-    
-    nil
-  end
-
-  def files
-    ftype('file')
-  end
-
-  def directories
-    ftype('directory')
-  end
-
-  protected
-  
-  def each(&block)
-    prefix='/'
-    super(prefix, &block)
-  end
-
-  def ftype(ft)
-    inject({}) do |hash, entry|
-      path, node = entry
-      hash["#{path}"] = node.mtime if node.ftype == ft
-      hash
-    end
-  end
-  
-  def descendant(path)
-    node = recurse_on_key(path, false)
-    node
-  end
-
-  def descendant!(path)
-    @mutex.lock
-    node = recurse_on_key(path, true)
-    @mutex.unlock
-    node
-  end
-
-  def sanitize_key(key)
-    key_for_path(absolute_path(key))
-  end
-end

data/lib/vendor/fssm/fsevents.rb

@@ -1,129 +0,0 @@
-OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
-
-module Rucola
-  class FSEvents
-    class FSEvent
-      attr_reader :fsevents_object
-      attr_reader :id
-      attr_reader :path
-      def initialize(fsevents_object, id, path)
-        @fsevents_object, @id, @path = fsevents_object, id, path
-      end
-      
-      # Returns an array of the files/dirs in the path that the event occurred in.
-      # The files are sorted by the modification time, the first entry is the last modified file.
-      def files
-        Dir.glob("#{File.expand_path(path)}/*").sort_by {|f| File.mtime(f) }.reverse
-      end
-      
-      # Returns the last modified file in the path that the event occurred in.
-      def last_modified_file
-        files.first
-      end
-    end
-    
-    class StreamError < StandardError; end
-    
-    attr_reader :paths
-    attr_reader :stream
-    
-    attr_accessor :allocator
-    attr_accessor :context
-    attr_accessor :since
-    attr_accessor :latency
-    attr_accessor :flags
-    
-    # Initializes a new FSEvents `watchdog` object and starts watching the directories you specify for events. The
-    # block is used as a handler for events, which are passed as the block's argument. This method is the easiest
-    # way to start watching some directories if you don't care about the details of setting up the event stream.
-    #
-    #   Rucola::FSEvents.start_watching('/tmp') do |events|
-    #     events.each { |event| log.debug("#{event.files.inspect} were changed.") }
-    #   end
-    #   
-    #   Rucola::FSEvents.start_watching('/var/log/system.log', '/var/log/secure.log', :since => last_id, :latency => 5) do
-    #     Growl.notify("Something was added to your log files!")
-    #   end
-    #
-    # Note that the method also returns the FSEvents object. This enables you to control the event stream if you want to.
-    #
-    #   fsevents = Rucola::FSEvents.start_watching('/Volumes') do |events|
-    #     events.each { |event| Growl.notify("Volume changes: #{event.files.to_sentence}") }
-    #   end
-    #   fsevents.stop
-    def self.start_watching(*params, &block)
-      fsevents = new(*params, &block)
-      fsevents.create_stream
-      fsevents.start
-      fsevents
-    end
-    
-    # Creates a new FSEvents `watchdog` object. You can specify a list of paths to watch and options to control the
-    # behaviour of the watchdog. The block you pass serves as a callback when an event is generated on one of the
-    # specified paths.
-    #
-    #   fsevents = FSEvents.new('/etc/passwd') { Mailer.send_mail("Someone touched the password file!") }
-    #   fsevents.create_stream
-    #   fsevents.start
-    #
-    #   fsevents = FSEvents.new('/home/upload', :since => UploadWatcher.last_event_id) do |events|
-    #     events.each do |event|
-    #       UploadWatcher.last_event_id = event.id
-    #       event.files.each do |file|
-    #         UploadWatcher.logfile.append("#{file} was changed")
-    #       end
-    #     end
-    #   end
-    #
-    # *:since: The service will report events that have happened after the supplied event ID. Never use 0 because that 
-    #   will cause every fsevent since the "beginning of time" to be reported. Use OSX::KFSEventStreamEventIdSinceNow
-    #   if you want to receive events that have happened after this call. (Default: OSX::KFSEventStreamEventIdSinceNow).
-    #   You can find the ID's passed with :since in the events passed to your block.
-    # *:latency: Number of seconds to wait until an FSEvent is reported, this allows the service to bundle events. (Default: 0.0)
-    #
-    # Please refer to the Cocoa documentation for the rest of the options.
-    def initialize(*params, &block)
-      raise ArgumentError, 'No callback block was specified.' unless block_given?
-      
-      options = params.last.kind_of?(Hash) ? params.pop : {}
-      @paths = params.flatten
-      
-      paths.each { |path| raise ArgumentError, "The specified path (#{path}) does not exist." unless File.exist?(path) }
-      
-      @allocator = options[:allocator] || OSX::KCFAllocatorDefault
-      @context   = options[:context]   || nil
-      @since     = options[:since]     || OSX::KFSEventStreamEventIdSinceNow
-      @latency   = options[:latency]   || 0.0
-      @flags     = options[:flags]     || 0
-      @stream    = options[:stream]    || nil
-      
-      @user_callback = block
-      @callback = Proc.new do |stream, client_callback_info, number_of_events, paths_pointer, event_flags, event_ids|
-        paths_pointer.regard_as('*')
-        events = []
-        number_of_events.times {|i| events << Rucola::FSEvents::FSEvent.new(self, event_ids[i], paths_pointer[i]) }
-        @user_callback.call(events)
-      end
-    end
-    
-    # Create the stream.
-    # Raises a Rucola::FSEvents::StreamError if the stream could not be created.
-    def create_stream
-      @stream = OSX.FSEventStreamCreate(@allocator, @callback, @context, @paths, @since, @latency, @flags)
-      raise(StreamError, 'Unable to create FSEvents stream.') unless @stream
-      OSX.FSEventStreamScheduleWithRunLoop(@stream, OSX.CFRunLoopGetCurrent, OSX::KCFRunLoopDefaultMode)
-    end
-    
-    # Start the stream.
-    # Raises a Rucola::FSEvents::StreamError if the stream could not be started.
-    def start
-      raise(StreamError, 'Unable to start FSEvents stream.') unless OSX.FSEventStreamStart(@stream)
-    end
-    
-    # Stop the stream.
-    # You can resume it by calling `start` again.
-    def stop
-      OSX.FSEventStreamStop(@stream)
-    end
-  end
-end