social_url_stats 0.0.1 → 0.0.2

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

@@ -1,57 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,257 +0,0 @@
-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