social_url_stats 0.0.1

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

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

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

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

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

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

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

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

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

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