social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/generator.rb

@@ -1,68 +0,0 @@
-module Tins
-  # This class can create generator objects, that can produce all tuples, that
-  # would be created by as many for-loops as dimensions were given.
-  #
-  # The generator
-  #  g = Tins::Generator[1..2, %w[a b c]]
-  # produces
-  #  g.to_a # => [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"], [2, "c"]]
-  #
-  # The 'each' method can be used to iterate over the tuples
-  #  g.each { |a, b| puts "#{a} #{b}" }
-  # and Tins::Generator includes the Enumerable module, so
-  # Enumerable.instance_methods can be used as well:
-  #  g.select { |a, b| %w[a c].include? b  } # => [[1, "a"], [1, "c"], [2, "a"], [2, "c"]]
-  #
-  class Generator
-    include Enumerable
-
-    # Create a new Generator object from the enumberables _enums_.
-    def self.[](*enums)
-      new(enums)
-    end
-
-    # Create a new Generator instance. Use the objects in the Array _enums_
-    # as dimensions. The should all respond to the :each method (see module
-    # Enumerable in the core ruby library).
-    def initialize(enums)
-      @enums, @iterators, @n = [], [], 0
-      enums.each { |e| add_dimension(e) }
-    end
-
-    # Iterate over all tuples produced by this generator and yield to them.
-    def each(&block) # :yield: tuple
-      recurse(&block)
-      self
-    end
-
-    def recurse(tuple = [ nil ] * @n, i = 0, &block)
-      if i < @n - 1 then
-        @enums[i].__send__(@iterators[i]) do |x|
-          tuple[i] = x
-          recurse(tuple, i + 1, &block)
-        end
-      else
-        @enums[i].__send__(@iterators[i]) do |x|
-          tuple[i] = x
-          yield tuple.dup
-        end
-      end
-    end
-    private :recurse
-
-    # Add another dimension to this generator. _enum_ is an object, that ought
-    # to respond to the _iterator_ method (defaults to :each).
-    def add_dimension(enum, iterator = :each)
-      @enums << enum
-      @iterators << iterator
-      @n += 1
-    end
-
-    # Return the size of this generator, that is the number of its dimensions.
-    def size
-      @enums.size
-    end
-  end
-end
-
-require 'tins/alias'

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/go.rb

@@ -1,69 +0,0 @@
-module Tins
-  module GO
-    module EnumerableExtension
-      def push(argument)
-        @arguments ||= []
-        @arguments.push argument
-        self
-      end
-
-      def each(&block)
-        @arguments.each(&block)
-        self
-      end
-      include Enumerable
-    end
-
-    module_function
-
-    # Parses the argument array _args_, according to the pattern _s_, to
-    # retrieve the single character command line options from it. If _s_ is
-    # 'xy:' an option '-x' without an option argument is searched, and an
-    # option '-y foo' with an option argument ('foo').
-    #
-    # An option hash is returned with all found options set to true or the
-    # found option argument.
-    def go(s, args = ARGV)
-      b, v = s.scan(/(.)(:?)/).inject([ {}, {} ]) { |t, (o, a)|
-        a = a == ':'
-        t[a ? 1 : 0][o] = a ? nil : false
-        t
-      }
-      while a = args.shift
-        a !~ /\A-(.+)/ and args.unshift a and break
-        p = $1
-        until p == ''
-          o = p.slice!(0, 1)
-          if v.key?(o)
-            if p == '' then
-              a = args.shift or break 1
-            else
-              a = p
-            end
-            if v[o].nil?
-              a = a.dup
-              a.extend EnumerableExtension
-              a.push a
-              v[o] = a
-            else
-              v[o].push a
-            end
-            break
-          elsif b.key?(o)
-            if b[o] == false
-              b[o]= 1
-            else
-              b[o] += 1
-            end
-          else
-            args.unshift a
-            break 1
-          end
-        end and break
-      end
-      b.merge(v)
-    end
-  end
-end
-
-require 'tins/alias'

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/hash_symbolize_keys_recursive.rb

@@ -1,28 +0,0 @@
-module Tins
-  module HashSymbolizeKeysRecursive
-    def symbolize_keys_recursive
-      inject(self.class.new) do |h,(k, v)|
-        k = k.to_s
-        k.empty? and next
-        case v
-        when Hash
-          h[k.to_sym] = v.symbolize_keys_recursive
-        when Array
-          h[k.to_sym] = a = v.dup
-          v.each_with_index do |x, i|
-            Hash === x and a[i] = x.symbolize_keys_recursive
-          end
-        else
-          h[k.to_sym] = v
-        end
-        h
-      end
-    end
-
-    def symbolize_keys_recursive!
-      replace symbolize_keys_recursive
-    end
-  end
-end
-
-require 'tins/alias'

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/hash_union.rb

@@ -1,15 +0,0 @@
-module Tins
-  module HashUnion
-    def |(other)
-      case
-      when other.respond_to?(:to_hash)
-        other = other.to_hash
-      when other.respond_to?(:to_h)
-        other = other.to_h
-      end
-      other.merge(self)
-    end
-  end
-end
-
-require 'tins/alias'

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/if_predicate.rb

@@ -1,7 +0,0 @@
-module Tins
-  module IfPredicate
-    def if?
-      self ? self : nil
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/limited.rb

@@ -1,38 +0,0 @@
-require 'thread'
-
-module Tins
-  class Limited
-    # Create a Limited instance, that runs _maximum_ threads at most.
-    def initialize(maximum)
-      @mutex =  Mutex.new
-      @continue = ConditionVariable.new
-      @maximum = Integer(maximum)
-      raise ArgumentError, "maximum < 1" if @maximum < 1
-      @count = 0
-    end
-
-    # The maximum number of worker threads.
-    attr_reader :maximum
-
-    # Execute _maximum_ number of threads in parallel.
-    def execute
-      @mutex.synchronize do
-        loop do
-          if @count < @maximum
-            @count += 1
-            Thread.new do
-              yield
-              @mutex.synchronize { @count -= 1 }
-              @continue.signal
-            end
-            return
-          else
-            @continue.wait(@mutex)
-          end
-        end
-      end
-    end
-  end
-end
-
-require 'tins/alias'

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/lines_file.rb

@@ -1,123 +0,0 @@
-module Tins
-  class LinesFile
-    module LineExtension
-      attr_reader :line_number
-
-      def filename
-        lines_file.filename.dup
-      end
-    end
-
-    def self.for_filename(filename, line_number = nil)
-      obj = new(File.readlines(filename), line_number)
-      obj.filename = filename
-      obj
-    end
-
-    def self.for_file(file, line_number = nil)
-      obj = new(file.readlines, line_number)
-      obj.filename = file.path
-      obj
-    end
-
-    def self.for_lines(lines, line_number = nil)
-      new(lines, line_number)
-    end
-
-    def initialize(lines, line_number = nil)
-      @lines = lines
-      @lines.each_with_index do |line, i|
-        line.extend LineExtension
-        line.instance_variable_set :@line_number, i + 1
-        line.instance_variable_set :@lines_file, self
-      end
-      instance_variable_set :@line_number, line_number || (@lines.empty? ? 0 : 1)
-    end
-
-    attr_accessor :filename
-
-    attr_reader :line_number
-
-    def rewind
-      self.line_number = 1
-      self
-    end
-
-    def next!
-      old = line_number
-      self.line_number += 1
-      line_number > old ? self : nil
-    end
-
-    def previous!
-      old = line_number
-      self.line_number -= 1
-      line_number < old ? self : nil
-    end
-
-    def line_number=(number)
-      number = number.to_i
-      if number > 0 && number <= last_line_number
-        @line_number = number
-      end
-    end
-
-    def last_line_number
-      @lines.size
-    end
-
-    def empty?
-      @lines.empty?
-    end
-
-    def each(&block)
-      empty? and return self
-      old_line_number = line_number
-      1.upto(last_line_number) do |number|
-        self.line_number = number
-        block.call(line)
-      end
-      self
-    ensure
-      self.line_number = old_line_number
-    end
-    include Enumerable
-
-    def line
-      index = line_number - 1
-      @lines[index] if index >= 0
-    end
-
-    def file_linenumber
-      "#{filename}:#{line_number}"
-    end
-
-    def match_backward(regexp, previous_after_match = false)
-      begin
-        if line =~ regexp
-          previous_after_match and previous!
-          return $~.captures
-        end
-      end while previous!
-    end
-
-    def match_forward(regexp, next_after_match = false)
-      begin
-        if line =~ regexp
-          next_after_match and next!
-          return $~.captures
-        end
-      end while next!
-    end
-
-    def to_s
-      "#{line_number} #{line.chomp}"
-    end
-
-    def inspect
-      "#<#{self.class}: #{to_s.inspect}>"
-    end
-  end
-end
-
-require 'tins/alias'

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/memoize.rb

@@ -1,71 +0,0 @@
-require 'tins/extract_last_argument_options'
-
-module Tins
-  module Memoize
-    module CacheMethods
-      # Return the cache object.
-      def __memoize_cache__
-        @__memoize_cache__ ||= {}
-      end
-
-      # Clear cached values for all methods/functions.
-      def memoize_cache_clear
-         __memoize_cache__.clear
-        self
-      end
-    end
-
-    class ::Module
-      # Automatically memoize calls of the the methods +method_ids+. The
-      # memoized results do NOT ONLY depend on the arguments, but ALSO on the
-      # object the method is called on.
-      def memoize_method(*method_ids)
-        method_ids.extend(ExtractLastArgumentOptions)
-        method_ids, opts = method_ids.extract_last_argument_options
-        include CacheMethods
-        method_ids.each do |method_id|
-          method_id = method_id.to_s.to_sym
-          orig_method = instance_method(method_id)
-          __send__(:define_method, method_id) do |*args|
-            mc = __memoize_cache__
-            if mc.key?(method_id) and result = mc[method_id][args]
-              result
-            else
-              (mc[method_id] ||= {})[args] = result = orig_method.bind(self).call(*args)
-              $DEBUG and warn "#{self.class} cached method #{method_id}(#{args.inspect unless args.empty?}) = #{result.inspect} [#{__id__}]"
-              opts[:freeze] and result.freeze
-            end
-            result
-          end
-        end
-      end
-
-      include CacheMethods
-
-      # Automatically memoize calls of the functions +function_ids+. The
-      # memoized result does ONLY depend on the arguments given to the
-      # function.
-      def memoize_function(*function_ids)
-        function_ids.extend(ExtractLastArgumentOptions)
-        function_ids, opts = function_ids.extract_last_argument_options
-        mc = __memoize_cache__
-        function_ids.each do |method_id|
-          method_id = method_id.to_s.to_sym
-          orig_method = instance_method(method_id)
-          __send__(:define_method, method_id) do |*args|
-            if mc.key?(method_id) and result = mc[method_id][args]
-              result
-            else
-              (mc[method_id] ||= {})[args] = result = orig_method.bind(self).call(*args)
-              opts[:freeze] and result.freeze
-              $DEBUG and warn "#{self.class} cached function #{method_id}(#{args.inspect unless args.empty?}) = #{result.inspect}"
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end
-
-require 'tins/alias'

data/vendor/ruby/1.9.1/gems/tins-0.13.1/lib/tins/method_description.rb

@@ -1,38 +0,0 @@
-module Tins
-  module MethodDescription
-    def description
-      result = ''
-      if owner <= Module
-        result << receiver.to_s << '.'
-      else
-        result << owner.name.to_s << '#'
-      end
-      result << name.to_s << '('
-      if respond_to?(:parameters)
-        generated_name = 'x0'
-        result << parameters.map { |p_type, p_name|
-          p_name ||= generated_name.succ!
-          case p_type
-          when :block
-            "&#{p_name}"
-          when :rest
-            "*#{p_name}"
-          when :keyrest
-            "**#{p_name}"
-          when :req
-            p_name
-          when :opt
-            "#{p_name}="
-          when :key
-            "#{p_name}:"
-          else
-            [ p_name, p_type ] * ':'
-          end
-        } * ','
-      else
-        result << arity.to_s
-      end
-      result << ')'
-    end
-  end
-end