social_url_stats 0.0.1

data/vendor/ruby/1.9.1/gems/watchr-0.7/lib/watchr/event_handlers/base.rb

@@ -0,0 +1,57 @@
+require 'observer'
+
+module Watchr
+  module EventHandler
+
+    # @private
+    class AbstractMethod < Exception; end
+
+    # Base functionality mixin, meant to be included in specific event handlers.
+    #
+    # @abstract
+    module Base
+      include Observable
+
+      # Notify that a file was modified.
+      #
+      # @param [Pathname, String] path
+      #   full path or path relative to current working directory
+      #
+      # @param [Symbol] event
+      #   event type.
+      #
+      # @return [undefined]
+      #
+      def notify(path, event_type = nil)
+        changed(true)
+        notify_observers(path, event_type)
+      end
+
+      # Begin watching given paths and enter listening loop. Called by the
+      # controller.
+      #
+      # @param [Array<Pathname>] monitored_paths
+      #   list of paths the application is currently monitoring.
+      #
+      # @return [undefined]
+      #
+      # @abstract
+      def listen(monitored_paths)
+        raise AbstractMethod
+      end
+
+      # Called by the controller when the list of paths monitored by wantchr
+      # has changed. It should refresh the list of paths being watched.
+      #
+      # @param [Array<Pathname>] monitored_paths
+      #   list of paths the application is currently monitoring.
+      #
+      # @return [undefined]
+      #
+      # @abstract
+      def refresh(monitored_paths)
+        raise AbstractMethod
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/watchr-0.7/lib/watchr/event_handlers/darwin.rb

@@ -0,0 +1,160 @@
+module Watchr
+  module EventHandler
+
+    class ::FSEvents
+      # Same as Watch.debug, but prefixed with [fsevents] instead.
+      #
+      # @example
+      #
+      #     FSEvents.debug('missfired')
+      #
+      # @param [String] message
+      #   debug message to print
+      #
+      # @return [nil]
+      #
+      def self.debug(msg)
+        puts "[fsevents] #{msg}" if Watchr.options.debug
+      end
+    end
+
+    # FSEvents based event handler for Darwin/OSX
+    #
+    # Uses ruby-fsevents (http://github.com/sandro/ruby-fsevent)
+    #
+    class Darwin < FSEvent
+      include Base
+
+      def initialize
+        super
+        self.latency = 0.2
+      end
+
+      # Enter listening loop. Will block control flow until application is
+      # explicitly stopped/killed.
+      #
+      # @return [undefined]
+      #
+      def listen(monitored_paths)
+        register_paths(monitored_paths)
+        start
+      end
+
+      # Rebuild file bindings. Will detach all current bindings, and reattach
+      # the `monitored_paths`
+      #
+      # @param [Array<Pathname>] monitored_paths
+      #   list of paths the application is currently monitoring.
+      #
+      # @return [undefined]
+      #
+      def refresh(monitored_paths)
+        register_paths(monitored_paths)
+        restart
+      end
+
+      private
+
+        # Callback. Called on file change event. Delegates to
+        # {Controller#update}, passing in path and event type
+        #
+        # @return [undefined]
+        #
+        def on_change(dirs)
+          dirs.each do |dir|
+            path, type = detect_change(dir)
+            notify(path, type) unless path.nil?
+          end
+        end
+
+        # Detected latest updated file within given directory
+        #
+        # @param [Pathname, String] dir
+        #   directory reporting event
+        #
+        # @return [Array(Pathname, Symbol)] path and type
+        #   path to updated file and event type
+        #
+        def detect_change(dir)
+          paths = monitored_paths_for(dir)
+          type  = nil
+          path  = paths.find {|path| type = event_type(path) }
+
+          FSEvents.debug("event detection error") if type.nil?
+
+          update_reference_times
+          [path, type]
+        end
+
+        # Detect type of event for path, if any
+        #
+        # Path times (atime, mtime, ctime) are compared to stored references.
+        # If any is more recent, the event is reported as a symbol.
+        #
+        # @param [Pathname] path
+        #
+        # @return [Symbol, nil] event type
+        #   Event type if detected, nil otherwise.
+        #   Symbol is on of :deleted, :modified, :accessed, :changed
+        #
+        def event_type(path)
+          return :deleted   if !path.exist?
+          return :modified  if  path.mtime > @reference_times[path][:mtime]
+          return :accessed  if  path.atime > @reference_times[path][:atime]
+          return :changed   if  path.ctime > @reference_times[path][:ctime]
+          nil
+        end
+
+        # Monitored paths within given dir
+        #
+        # @param [Pathname, String] dir
+        #
+        # @return [Array<Pathname>] monitored_paths
+        #
+        def monitored_paths_for(dir)
+          dir = Pathname(dir).expand_path
+          @paths.select {|path| path.dirname.expand_path == dir }
+        end
+
+        # Register watches for paths
+        #
+        # @param [Array<Pathname>] paths
+        #
+        # @return [undefined]
+        #
+        def register_paths(paths)
+          @paths = paths
+          watch_directories(dirs_for(@paths))
+          update_reference_times
+        end
+
+        # Directories for paths
+        #
+        # A unique list of directories containing given paths
+        #
+        # @param [Array<Pathname>] paths
+        #
+        # @return [Array<Pathname>] dirs
+        #
+        def dirs_for(paths)
+          paths.map {|path| path.dirname.to_s }.uniq
+        end
+
+        # Update reference times for registered paths
+        #
+        # @return [undefined]
+        #
+        def update_reference_times
+          @reference_times = {}
+          now = Time.now
+          @paths.each do |path|
+            @reference_times[path] = {}
+            @reference_times[path][:atime] = now
+            @reference_times[path][:mtime] = now
+            @reference_times[path][:ctime] = now
+          end
+        end
+    end
+  end
+end
+

data/vendor/ruby/1.9.1/gems/watchr-0.7/lib/watchr/event_handlers/portable.rb

@@ -0,0 +1,75 @@
+module Watchr
+  module EventHandler
+    class Portable
+      include Base
+
+      def initialize
+        @reference_mtime = @reference_atime = @reference_ctime = Time.now
+      end
+
+      # Enters listening loop.
+      #
+      # Will block control flow until application is explicitly stopped/killed.
+      #
+      # @param [Array<Pathname>] monitored_paths
+      #   list of paths the application is currently monitoring.
+      #
+      # @return [undefined]
+      #
+      def listen(monitored_paths)
+        @monitored_paths = monitored_paths
+        loop { trigger; sleep(1) }
+      end
+
+      # See if an event occured, and if so notify observers.
+      #
+      # @return [undefined]
+      #
+      # @private
+      def trigger
+        path, type = detect_event
+        notify(path, type) unless path.nil?
+      end
+
+      # Update list of monitored paths.
+      #
+      # @param [Array<Pathname>] monitored_paths
+      #   list of paths the application is currently monitoring.
+      #
+      # @return [undefined]
+      #
+      def refresh(monitored_paths)
+        @monitored_paths = monitored_paths
+      end
+
+      private
+
+      # Verify mtimes of monitored files.
+      #
+      # If the latest mtime is more recent than the reference mtime, return
+      # that file's path.
+      #
+      # @return [[Pathname, Symbol]]
+      #   path and type of event if event occured, nil otherwise
+      #
+      # @todo improve ENOENT error handling
+      #
+      def detect_event # OPTIMIZE, REFACTOR
+        @monitored_paths.each do |path|
+          return [path, :deleted] unless path.exist?
+        end
+
+        mtime_path = @monitored_paths.max {|a,b| a.mtime <=> b.mtime }
+        atime_path = @monitored_paths.max {|a,b| a.atime <=> b.atime }
+        ctime_path = @monitored_paths.max {|a,b| a.ctime <=> b.ctime }
+
+        if    mtime_path.mtime > @reference_mtime then @reference_mtime = mtime_path.mtime; [mtime_path, :modified]
+        elsif atime_path.atime > @reference_atime then @reference_atime = atime_path.atime; [atime_path, :accessed]
+        elsif ctime_path.ctime > @reference_ctime then @reference_ctime = ctime_path.ctime; [ctime_path, :changed ]
+        else; nil; end
+      rescue Errno::ENOENT
+        retry
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/watchr-0.7/lib/watchr/event_handlers/unix.rb

@@ -0,0 +1,125 @@
+module Watchr
+  module EventHandler
+    class Unix
+      include Base
+
+      # Used by Rev. Wraps a monitored path, and `Rev::Loop` will call its
+      # callback on file events.
+      #
+      # @private
+      class SingleFileWatcher < Rev::StatWatcher
+        class << self
+          # Stores a reference back to handler so we can call its {Base#notify notify}
+          # method with file event info
+          #
+          # @return [EventHandler::Base]
+          #
+          attr_accessor :handler
+        end
+
+        # @param [String] path
+        #   single file to monitor
+        #
+        def initialize(path)
+          super
+          update_reference_times
+        end
+
+        # File's path as a Pathname
+        #
+        # @return [Pathname]
+        #
+        def pathname
+          @pathname ||= Pathname(@path)
+        end
+
+        # Callback. Called on file change event. Delegates to
+        # {Controller#update}, passing in path and event type
+        #
+        # @return [undefined]
+        #
+        def on_change
+          self.class.handler.notify(path, type)
+          update_reference_times unless type == :deleted
+        end
+
+        private
+
+        # @todo improve ENOENT error handling
+        def update_reference_times
+          @reference_atime = pathname.atime
+          @reference_mtime = pathname.mtime
+          @reference_ctime = pathname.ctime
+        rescue Errno::ENOENT
+          retry
+        end
+
+        # Type of latest event.
+        #
+        # A single type is determined, even though more than one stat times may
+        # have changed on the file. The type is the first to match in the
+        # following hierarchy:
+        #
+        #     :deleted, :modified (mtime), :accessed (atime), :changed (ctime)
+        #
+        # @return [Symbol] type
+        #   latest event's type
+        #
+        def type
+          return :deleted   if !pathname.exist?
+          return :modified  if  pathname.mtime > @reference_mtime
+          return :accessed  if  pathname.atime > @reference_atime
+          return :changed   if  pathname.ctime > @reference_ctime
+        end
+      end
+
+      def initialize
+        SingleFileWatcher.handler = self
+        @loop = Rev::Loop.default
+      end
+
+      # Enters listening loop. Will block control flow until application is
+      # explicitly stopped/killed.
+      #
+      # @return [undefined]
+      #
+      def listen(monitored_paths)
+        @monitored_paths = monitored_paths
+        attach
+        @loop.run
+      end
+
+      # Rebuilds file bindings. Will detach all current bindings, and reattach
+      # the `monitored_paths`
+      #
+      # @param [Array<Pathname>] monitored_paths
+      #   list of paths the application is currently monitoring.
+      #
+      # @return [undefined]
+      #
+      def refresh(monitored_paths)
+        @monitored_paths = monitored_paths
+        detach
+        attach
+      end
+
+      private
+
+      # Binds all `monitored_paths` to the listening loop.
+      #
+      # @return [undefined]
+      #
+      def attach
+        @monitored_paths.each {|path| SingleFileWatcher.new(path.to_s).attach(@loop) }
+      end
+
+      # Unbinds all paths currently attached to listening loop.
+      #
+      # @return [undefined]
+      #
+      def detach
+        @loop.watchers.each {|watcher| watcher.detach }
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/watchr-0.7/lib/watchr/script.rb

@@ -0,0 +1,257 @@
+module Watchr
+
+  # A script object wraps a script file, and is used by a controller.
+  #
+  # @example
+  #
+  #     path   = Pathname.new('specs.watchr')
+  #     script = Watchr::Script.new(path)
+  #
+  class Script
+
+    # @private
+    DEFAULT_EVENT_TYPE = :modified
+
+    # Convenience type. Provides clearer and simpler access to rule properties.
+    #
+    # @example
+    #
+    #     rule = script.watch('lib/.*\.rb') { 'ohaie' }
+    #     rule.pattern      #=> 'lib/.*\.rb'
+    #     rule.action.call  #=> 'ohaie'
+    #
+    Rule = Struct.new(:pattern, :event_type, :action)
+
+    # Script file evaluation context
+    #
+    # Script files are evaluated in the context of an instance of this class so
+    # that they get a clearly defined set of methods to work with. In other
+    # words, it is the user script's API.
+    #
+    # @private
+    class EvalContext #:nodoc:
+
+      def initialize(script)
+        @__script = script
+      end
+
+      # Delegated to script
+      def default_action(&action)
+        @__script.default_action(&action)
+      end
+
+      # Delegated to script
+      def watch(*args, &block)
+        @__script.watch(*args, &block)
+      end
+
+      # Reload script
+      def reload
+        @__script.parse!
+      end
+    end
+
+    # EvalContext instance
+    #
+    # @example
+    #
+    #     script.ec.watch('pattern') { }
+    #     script.ec.reload
+    #
+    # @return [EvalContext]
+    #
+    attr_reader :ec
+
+    # Defined rules
+    #
+    # @return [Rule]
+    #   all rules defined with `#watch` calls
+    #
+    attr_reader :rules
+
+    # Create a Script object for script at `path`
+    #
+    # @param [Pathname] path
+    #   the path to the script
+    #
+    def initialize(path = nil)
+      @path = path
+      @rules = []
+      @default_action = Proc.new {}
+      @ec = EvalContext.new(self)
+    end
+
+    # Main script API method. Builds a new rule, binding a pattern to an action.
+    #
+    # Whenever a file is saved that matches a rule's `pattern`, its
+    # corresponding `action` is triggered.
+    #
+    # Patterns can be either a Regexp or a string. Because they always
+    # represent paths however, it's simpler to use strings. But remember to use
+    # single quotes (not double quotes), otherwise escape sequences will be
+    # parsed (for example `"foo/bar\.rb" #=> "foo/bar.rb"`, notice "\." becomes
+    # "."), and won't be interpreted as the regexp you expect.
+    #
+    # Also note that patterns will be matched against relative paths (relative
+    # to current working directory).
+    #
+    # Actions, the blocks passed to `watch`, receive a `MatchData` object as
+    # argument. It will be populated with the whole matched string ( `md[0]` )
+    # as well as individual backreferences ( `md[1..n]` ). See `MatchData#[]`
+    # documentation for more details.
+    #
+    # @example
+    #
+    #     # in script file
+    #     watch( 'test/test_.*\.rb' )  {|md| system("ruby #{md[0]}") }
+    #     watch( 'lib/(.*)\.rb' )      {|md| system("ruby test/test_#{md[1]}.rb") }
+    #
+    # With these two rules, watchr will run any test file whenever it is itself
+    # changed (first rule), and will also run a corresponding test file
+    # whenever a lib file is changed (second rule).
+    #
+    # @param [#match] pattern
+    #   pattern to match targetted paths
+    #
+    # @param [Symbol] event_type
+    #   rule will only match events of this type. Accepted types are
+    #   `:accessed`, `:modified`, `:changed`, `:delete` and `nil` (any), where
+    #   the first three correspond to atime, mtime and ctime respectively.
+    #   Defaults to `:modified`.
+    #
+    # @yield
+    #   action to trigger
+    #
+    # @return [Rule]
+    #
+    def watch(pattern, event_type = DEFAULT_EVENT_TYPE, &action)
+      @rules << Rule.new(pattern, event_type, action || @default_action)
+      @rules.last
+    end
+
+    # Convenience method. Define a default action to be triggered when a rule
+    # has none specified. When called without a block, acts as a getter and
+    # returns stored default_action
+    #
+    # @example
+    #
+    #     # in script file
+    #
+    #     default_action { system('rake --silent yard') }
+    #
+    #     watch( 'lib/.*\.rb'  )
+    #     watch( 'README.md'   )
+    #     watch( 'TODO.txt'    )
+    #     watch( 'LICENSE'     )
+    #
+    #     # is equivalent to:
+    #
+    #     watch( 'lib/.*\.rb'  ) { system('rake --silent yard') }
+    #     watch( 'README.md'   ) { system('rake --silent yard') }
+    #     watch( 'TODO.txt'    ) { system('rake --silent yard') }
+    #     watch( 'LICENSE'     ) { system('rake --silent yard') }
+    #
+    # @return [Proc]
+    #   default action
+    #
+    def default_action(&action)
+      @default_action = action if action
+      @default_action
+    end
+
+    # Reset script state
+    def reset
+      @rules = []
+      @default_action = Proc.new {}
+    end
+
+    # Eval content of script file.
+    #
+    # @todo improve ENOENT error handling
+    def parse!
+      return unless @path
+      reset
+      @ec.instance_eval(@path.read, @path.to_s)
+    rescue Errno::ENOENT
+      sleep(0.3) #enough?
+      retry
+    ensure
+      Watchr.debug('loaded script file %s' % @path.to_s.inspect)
+    end
+
+    # Find an action corresponding to a path and event type. The returned
+    # action is actually a wrapper around the rule's action, with the
+    # match_data prepopulated.
+    #
+    # @example
+    #
+    #     script.watch( 'test/test_.*\.rb' ) {|md| "ruby #{md[0]}" }
+    #     script.action_for('test/test_watchr.rb').call #=> "ruby test/test_watchr.rb"
+    #
+    # @param [Pathname, String] path
+    #   find action that corresponds to this path.
+    #
+    # @param [Symbol] event_type
+    #   find action only if rule's event is of this type.
+    #
+    # @return [Proc]
+    #   action, preparsed and ready to be called
+    #
+    def action_for(path, event_type = DEFAULT_EVENT_TYPE)
+      path = rel_path(path).to_s
+      rule = rules_for(path).detect {|rule| rule.event_type.nil? || rule.event_type == event_type }
+      if rule
+        data = path.match(rule.pattern)
+        lambda { rule.action.call(data) }
+      else
+        lambda {}
+      end
+    end
+
+    # Collection of all patterns defined in script.
+    #
+    # @return [Array<String,Regexp>]
+    #   all defined patterns
+    #
+    def patterns
+      #@rules.every.pattern
+      @rules.map {|r| r.pattern }
+    end
+
+    # Path to the script file corresponding to this object
+    #
+    # @return [Pathname]
+    #   absolute path to script file
+    #
+    def path
+      @path && Pathname(@path.respond_to?(:to_path) ? @path.to_path : @path.to_s).expand_path
+    end
+
+    private
+
+    # Rules corresponding to a given path, in reversed order of precedence
+    # (latest one is most inportant).
+    #
+    # @param [Pathname, String] path
+    #   path to look up rule for
+    #
+    # @return [Array<Rule>]
+    #   rules corresponding to `path`
+    #
+    def rules_for(path)
+      @rules.reverse.select {|rule| path.match(rule.pattern) }
+    end
+
+    # Make a path relative to current working directory.
+    #
+    # @param [Pathname, String] path
+    #   absolute or relative path
+    #
+    # @return [Pathname]
+    #   relative path, from current working directory.
+    #
+    def rel_path(path)
+      Pathname(path).expand_path.relative_path_from(Pathname(Dir.pwd))
+    end
+  end
+end