social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/watchr-0.7/Rakefile

@@ -1,34 +0,0 @@
-def gem_opt
-  defined?(Gem) ? "-rubygems" : ""
-end
-
-def ruby
-  require 'rbconfig'
-  File.join([Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']]) << Config::CONFIG['EXEEXT']
-end
-
-# --------------------------------------------------
-# Tests
-# --------------------------------------------------
-task(:default => "test:all")
-
-namespace(:test) do
-
-  desc "Run all tests"
-  task(:all) do
-    tests = Dir['test/**/test_*.rb'] - ['test/test_helper.rb']
-    exit system(%Q{#{ruby} #{gem_opt} -I.:lib -e"%w( #{tests.join(' ')} ).each {|file| require file }"})
-  end
-
-  desc "Run all tests on multiple ruby versions (requires rvm)"
-  task(:portability) do
-    %w( 1.8.6  1.8.7  1.9.1  1.9.2 ).each do |version|
-      system <<-BASH
-        bash -c 'source ~/.rvm/scripts/rvm;
-                 rvm #{version};
-                 echo "--------- v#{version} ----------\n";
-                 rake -s test:all'
-      BASH
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/watchr-0.7/TODO.md

@@ -1,31 +0,0 @@
-Features
---------
-
-* watchr -e ( `$ watchr -e "watch('foo.gemspec') { system('gem build foo.gemspec') }"` )
-* watchr --auto
-* watchr --fetch
-
-* enable ability to watch dirs
-  * requires new handler(s)
-  * will allow recognizing `:added` events
-
-* allow setting latency
-
-Bugs
-----
-
-* sometimes an action is fired without a file being saved
-  * buffer flushing issue?
-  * libev issue?
-  * probably fixed with event type handling update, which ignores atime
-    updates by defaults
-
-* when a file is saved twice quickly, subsequent events are ignored.
-  * seems like rev/libev drops the file watch
-
-Other
------
-
-* add tests for executable
-* memory profiling / benchmarks
-

data/vendor/ruby/1.9.1/gems/watchr-0.7/bin/watchr

@@ -1,105 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'pathname'
-require 'optparse'
-require 'tempfile'
-
-require File.dirname(__FILE__) + '/../lib/watchr'
-
-module Watchr
-  # Namespaced to avoid defining global methods
-  #
-  # @private
-  module Bin
-    extend self
-
-    DEFAULT_SCRIPT_PATH = Pathname.new('specs.watchr')
-
-    attr_accessor :path
-
-    def usage
-      "Usage: watchr [opts] path/to/script"
-    end
-
-    def version
-      "watchr version: %s" % Watchr::VERSION
-    end
-
-    # Absolute path to script file
-    #
-    # Unless set manually, the script's path is either first arg or
-    # `DEFAULT_SCRIPT_PATH`. If neither exists, the script immediatly aborts
-    # with an appropriate error message.
-    #
-    # @return [Pathname]
-    #   absolute path to script
-    #
-    def path!
-      return @path unless @path.nil?
-      rel = relative_path    or abort( usage )
-      find_in_load_path(rel) or abort("no script found: file #{rel.to_s.inspect} is not in path.")
-    end
-
-    # Find a partial path name in load path
-    #
-    # @param [Pathname] path
-    #   partial pathname
-    #
-    # @return [Pathname]
-    #   absolute path of first occurence of partial path in load path, or nil if not found
-    #
-    def find_in_load_path(path)
-      # Adds '.' for ruby1.9.2
-      dir = (['.'] + $LOAD_PATH).uniq.detect {|p| Pathname(p).join(path).exist? }
-      dir ? path.expand_path(dir) : nil
-    end
-
-    private
-
-    def relative_path
-      return Pathname.new(ARGV.first) if ARGV.first
-      return DEFAULT_SCRIPT_PATH      if DEFAULT_SCRIPT_PATH.exist?
-    end
-  end
-end
-
-opts = OptionParser.new do |opts|
-  opts.banner = Watchr::Bin.usage
-
-  opts.on('-d', '--debug', "Print extra debug info while program runs") {
-    Watchr.options.debug = true
-    begin
-      require 'ruby-debug'
-    rescue LoadError, RuntimeError
-    end
-  }
-  opts.on('-l', '--list', "Display list of files monitored by script and exit") {
-    script     = Watchr::Script.new(Watchr::Bin.path!)
-    controller = Watchr::Controller.new(script, Watchr.handler.new)
-    script.parse!
-    puts controller.monitored_paths
-    exit
-  }
-
-  def assert_syntax(code)
-    catch(:ok) { Object.new.instance_eval("BEGIN { throw :ok }; #{code}", %|-e "#{code}"|, 0) }
-  rescue SyntaxError => e
-    puts e.message.split("\n")[1]
-    exit
-  end
-
-  opts.on('-e', '--eval INLINE_SCRIPT', %|Evaluate script inline ($ watchr -e "watch('foo') { puts 'bar' }")|) {|code|
-    assert_syntax(code)
-
-    Tempfile.open('foo') {|f| f << code; @__path = f.path }
-    Watchr::Bin.path = Pathname(@__path)
-  }
-
-  opts.on_tail('-h', '--help', "Print inline help") { puts opts; exit }
-  opts.on_tail('-v', '--version', "Print version" ) { puts Watchr::Bin.version; exit }
-
-  opts.parse! ARGV
-end
-
-Watchr::Controller.new(Watchr::Script.new(Watchr::Bin.path!), Watchr.handler.new).run
-

data/vendor/ruby/1.9.1/gems/watchr-0.7/contributions.txt

@@ -1,7 +0,0 @@
-
-Suggestions:
-  macournoyer, foca
-
-Patches:
-  TwP, gzuki, spraints, francois
-

data/vendor/ruby/1.9.1/gems/watchr-0.7/docs.watchr

@@ -1,26 +0,0 @@
-# Run me with:
-#   $ watchr docs.watchr
-
-require 'yard'
-# --------------------------------------------------
-# Rules
-# --------------------------------------------------
-watch( 'lib/.*\.rb' ) { yard }
-watch( 'README.md'  ) { yard }
-watch( 'TODO.md'    ) { yard }
-watch( 'LICENSE'    ) { yard }
-
-# --------------------------------------------------
-# Signal Handling
-# --------------------------------------------------
-Signal.trap('QUIT') { yard }        # Ctrl-\
-Signal.trap('INT' ) { abort("\n") } # Ctrl-C
-
-# --------------------------------------------------
-# Helpers
-# --------------------------------------------------
-def yard
-  print "Updating yardocs... "; STDOUT.flush
-  YARD::CLI::Yardoc.run *%w( -o doc/yard --readme README.md --markup markdown - LICENSE TODO.md )
-  print "done\n"
-end

data/vendor/ruby/1.9.1/gems/watchr-0.7/gem.watchr

@@ -1,22 +0,0 @@
-# Run me with:
-#   $ watchr gem.watchr
-
-def gemspec() Dir['*.gemspec'].first end
-# --------------------------------------------------
-# Rules
-# --------------------------------------------------
-watch( gemspec ) { build }
-
-# --------------------------------------------------
-# Signal Handling
-# --------------------------------------------------
-Signal.trap('QUIT') { build }       # Ctrl-\
-Signal.trap('INT' ) { abort("\n") } # Ctrl-C
-
-# --------------------------------------------------
-# Helpers
-# --------------------------------------------------
-def build
-  puts; system "gem build #{gemspec}"
-  FileUtils.mv( Dir['*.gem'], 'pkg/' )
-end

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

@@ -1,133 +0,0 @@
-require 'pathname'
-require 'rbconfig'
-
-# Agile development tool that monitors a directory recursively, and triggers a
-# user defined action whenever an observed file is modified. Its most typical
-# use is continuous testing.
-#
-# See README for more details
-#
-# @example
-#
-#     # on command line, from project's root dir
-#     $ watchr path/to/script
-#
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-module Watchr
-  VERSION = '0.7'
-
-  begin
-    require 'fsevent'
-    HAVE_FSE = true
-  rescue LoadError, RuntimeError
-    HAVE_FSE = false
-  end
-
-  begin
-    require 'rev'
-    HAVE_REV = true
-  rescue LoadError, RuntimeError
-    HAVE_REV = false
-  end
-
-  autoload :Script,     'watchr/script'
-  autoload :Controller, 'watchr/controller'
-
-  module EventHandler
-    autoload :Base,     'watchr/event_handlers/base'
-    autoload :Portable, 'watchr/event_handlers/portable'
-    autoload :Unix,     'watchr/event_handlers/unix'      if ::Watchr::HAVE_REV
-    autoload :Darwin,   'watchr/event_handlers/darwin'    if ::Watchr::HAVE_FSE
-  end
-
-  class << self
-    attr_accessor :options
-    attr_accessor :handler
-
-    # @deprecated
-    def version #:nodoc:
-      Watchr::VERSION
-    end
-
-    # Options proxy.
-    #
-    # Currently supported options:
-    #
-    # * debug[Boolean] Debugging state. More verbose.
-    #
-    # @example
-    #
-    #     Watchr.options.debug #=> false
-    #     Watchr.options.debug = true
-    #
-    # @return [Struct]
-    #   options proxy.
-    #
-    def options
-      @options ||= Struct.new(:debug).new
-      @options.debug ||= false
-      @options
-    end
-
-    # Outputs formatted debug statement to stdout, only if `::options.debug` is true
-    #
-    # @example
-    #
-    #     Watchr.options.debug = true
-    #     Watchr.debug('im in ur codes, notifayinin u')
-    #
-    #     #outputs: "[watchr debug] im in ur codes, notifayinin u"
-    #
-    # @param [String] message
-    #   debug message to print
-    #
-    # @return [nil]
-    #
-    def debug(msg)
-      puts "[watchr debug] #{msg}" if options.debug
-    end
-
-    # Detect current OS and return appropriate handler.
-    #
-    # @example
-    #
-    #     Config::CONFIG['host_os'] #=> 'linux-gnu'
-    #     Watchr.handler #=> Watchr::EventHandler::Unix
-    #
-    #     Config::CONFIG['host_os'] #=> 'cygwin'
-    #     Watchr.handler #=> Watchr::EventHandler::Portable
-    #
-    #     ENV['HANDLER'] #=> 'unix'
-    #     Watchr.handler #=> Watchr::EventHandler::Unix
-    #
-    #     ENV['HANDLER'] #=> 'portable'
-    #     Watchr.handler #=> Watchr::EventHandler::Portable
-    #
-    # @return [Class]
-    #   handler class for current architecture
-    #
-    def handler
-      @handler ||=
-        case ENV['HANDLER'] || Config::CONFIG['host_os']
-          when /darwin|mach|osx|fsevents?/i
-            if Watchr::HAVE_FSE
-              Watchr::EventHandler::Darwin
-            else
-              Watchr.debug "fsevent not found. `gem install ruby-fsevent` to get evented handler"
-              Watchr::EventHandler::Portable
-            end
-          when /sunos|solaris|bsd|linux|unix/i
-            if Watchr::HAVE_REV
-              Watchr::EventHandler::Unix
-            else
-              Watchr.debug "rev not found. `gem install rev` to get evented handler"
-              Watchr::EventHandler::Portable
-            end
-          when /mswin|windows|cygwin/i
-            Watchr::EventHandler::Portable
-          else
-            Watchr::EventHandler::Portable
-        end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-module Watchr
-
-  # The controller contains the app's core logic.
-  #
-  # @example
-  #
-  #     script = Watchr::Script.new(file)
-  #     contrl = Watchr::Controller.new(script, Watchr.handler.new)
-  #     contrl.run
-  #
-  #     # Calling `run` will enter the listening loop, and from then on every
-  #     # file event will trigger its corresponding action defined in `script`
-  #
-  #     # The controller also automatically adds the script's file to its list of
-  #     # monitored files and will detect any changes to it, providing on the fly
-  #     # updates of defined rules.
-  #
-  class Controller
-
-    # Create a controller object around given `script`
-    #
-    # @param [Script] script
-    #   The script object
-    #
-    # @param [EventHandler::Base] handler
-    #   The filesystem event handler
-    #
-    # @see Watchr::Script
-    # @see Watchr.handler
-    #
-    def initialize(script, handler)
-      @script, @handler = script, handler
-      @handler.add_observer(self)
-
-      Watchr.debug "using %s handler" % handler.class.name
-    end
-
-    # Enter listening loop. Will block control flow until application is
-    # explicitly stopped/killed.
-    def run
-      @script.parse!
-      @handler.listen(monitored_paths)
-    rescue Interrupt
-    end
-
-    # Callback for file events
-    #
-    # Called while control flow is in listening loop. It will execute the
-    # file's corresponding action as defined in the script. If the file is the
-    # script itself, it will refresh its state to account for potential changes.
-    #
-    # @param [Pathname, String] path
-    #   path that triggered the event
-    #
-    # @param [Symbol] event
-    #   event type
-    #
-    def update(path, event_type = nil)
-      path = Pathname(path).expand_path
-
-      Watchr.debug("received #{event_type.inspect} event for #{path.relative_path_from(Pathname(Dir.pwd))}")
-      if path == @script.path
-        @script.parse!
-        @handler.refresh(monitored_paths)
-      else
-        @script.action_for(path, event_type).call
-      end
-    end
-
-    # List of paths the script is monitoring.
-    #
-    # Basically this means all paths below current directoly recursivelly that
-    # match any of the rules' patterns, plus the script file.
-    #
-    # @return [Array<Pathname>]
-    #   list of all monitored paths
-    #
-    def monitored_paths
-      paths = Dir['**/*'].select do |path|
-        @script.patterns.any? {|p| path.match(p) }
-      end
-      paths.push(@script.path).compact!
-      paths.map {|path| Pathname(path).expand_path }
-    end
-  end
-end
-