social_url_stats 0.0.1 → 0.0.2

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

@@ -1,55 +0,0 @@
-module Tins
-  # This module can be mixed into all classes, whose instances respond to the
-  # [] and size-methods, like for example Array. The returned elements from []
-  # should respond to the succ method.
-  module Minimize
-    # Returns a minimized version of this object, that is successive elements
-    # are substituted with ranges a..b. In the situation ..., x, y,... and y !=
-    # x.succ a range x..x is created, to make it easier to iterate over all the
-    # ranges in one run. A small example:
-    #  [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ].minimize # => [ 'A'..'C', 'G'..'G', 'K'..'M' ]
-    #
-    # If the order of the original elements doesn't matter, it's a good idea to
-    # first sort them and then minimize:
-    #  [ 5, 1, 4, 2 ].sort.minimize # => [ 1..2, 4..5 ]
-    def minimize
-      result = []
-      last_index = size - 1
-      size.times do |i|
-        result << [ self[0] ] if i == 0
-        if self[i].succ != self[i + 1] or i == last_index
-          result[-1] << self[i]
-          result << [ self[i + 1] ] unless i == last_index
-        end
-      end
-      result.map! { |a, b| a..b }
-    end
-
-    # First minimizes this object, then calls the replace method with the
-    # result.
-    def minimize!
-      replace minimize
-    end
-
-    # Invert a minimized version of an object. Some small examples:
-    #  [ 'A'..'C', 'G'..'G', 'K'..'M' ].unminimize # => [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ]
-    # and
-    #  [ 1..2, 4..5 ].unminimize # => [ 1, 2, 4, 5 ]
-    def unminimize
-      result = []
-      for range in self
-        for e in range
-          result << e
-        end
-      end
-      result
-    end
-
-    # Invert a minimized version of this object in place.
-    def unminimize!
-      replace unminimize
-    end
-  end
-end
-
-require 'tins/alias'

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

@@ -1,13 +0,0 @@
-module Tins
-  module ModuleGroup
-    def self.[](*modules)
-      modul = Module.new
-      modules.each do |m|
-        m.module_eval { include modul }
-      end
-      modul
-    end
-  end
-end
-
-require 'tins/alias'

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

@@ -1,12 +0,0 @@
-require 'set'
-
-module Tins
-  class NamedSet < Set
-    def initialize(name)
-      @name = name
-      super()
-    end
-
-    attr_accessor :name
-  end
-end

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

@@ -1,92 +0,0 @@
-module Tins
-  # Implementation of the null object pattern in Ruby.
-  module Null
-    def method_missing(*)
-      self
-    end
-
-    def const_missing(*)
-      self
-    end
-
-    def to_s
-      ''
-    end
-
-    def to_str
-      nil
-    end
-
-    def to_f
-      0.0
-    end
-
-    def to_i
-      0
-    end
-
-    def to_int
-      nil
-    end
-
-    def to_a
-      []
-    end
-
-    def to_ary
-      nil
-    end
-
-    def inspect
-      'NULL'
-    end
-
-    def nil?
-      true
-    end
-
-    def blank?
-      true
-    end
-
-    module Kernel
-      def null(value = nil)
-        value.nil? ? Tins::NULL : value
-      end
-
-      alias Null null
-
-      def null_plus(opts = {})
-        value = opts[:value]
-        opts[:caller] = caller
-        if respond_to?(:caller_locations, true)
-          opts[:caller_locations] = caller_locations
-        end
-
-        value.nil? ? Tins::NullPlus.new(opts) : value
-      end
-
-      alias NullPlus null_plus
-    end
-  end
-
-  class NullClass < Module
-    include Tins::Null
-  end
-
-  NULL = NullClass.new.freeze
-
-  class NullPlus
-    include Tins::Null
-
-    def initialize(opts = {})
-      class << self; self; end.class_eval do
-        opts.each do |name, value|
-          define_method(name) { value }
-        end
-      end
-    end
-  end
-end
-
-require 'tins/alias'

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

@@ -1,25 +0,0 @@
-module Tins
-  module Once
-    include File::Constants
-
-    module_function
-
-    def only_once(lock_filename = nil, locking_constant = nil)
-      lock_filename ||= $0
-      locking_constant ||= LOCK_EX
-      f = File.new(lock_filename, RDONLY)
-      f.flock(locking_constant) and yield
-    ensure
-      if f
-        f.flock LOCK_UN
-        f.close
-      end
-    end
-
-    def try_only_once(lock_filename = nil, locking_constant = nil, &block)
-      only_once(lock_filename, locking_constant || LOCK_EX | LOCK_NB, &block)
-    end
-  end
-end
-
-require 'tins/alias'

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

@@ -1,23 +0,0 @@
-require 'pp'
-
-module Tins
-  module P
-    private
-
-    # Raise a runtime error with the inspected objects +objs+ (obtained by
-    # calling the #inspect method) as their message text. This is useful for
-    # quick debugging.
-    def p!(*objs)
-      raise((objs.size < 2 ? objs.first : objs).inspect)
-    end
-
-    # Raise a runtime error with the inspected objects +objs+ (obtained by
-    # calling the #pretty_inspect method) as their message text. This is useful
-    # for quick debugging.
-    def pp!(*objs)
-      raise("\n" + (objs.size < 2 ? objs.first : objs).pretty_inspect.chomp)
-    end
-  end
-end
-
-require 'tins/alias'

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

@@ -1,31 +0,0 @@
-module Tins
-  module PartialApplication
-    # If this module is included into a Proc (or similar object), it tampers
-    # with its Proc#arity method.
-    def self.included(modul)
-      modul.module_eval do
-        old_arity = instance_method(:arity)
-        define_method(:arity) do
-          @__arity__ or old_arity.bind(self).call
-        end
-      end
-      super
-    end
-
-    # Create a partial application of this Proc (or similar object) using
-    # _args_ as the already applied arguments.
-    def partial(*args)
-      if args.empty?
-        dup
-      elsif args.size > arity
-        raise ArgumentError, "wrong number of arguments (#{args.size} for #{arity})"
-      else
-        f = lambda { |*b| call(*(args + b)) }
-        f.instance_variable_set :@__arity__, arity - args.size
-        f
-      end
-    end
-  end
-end
-
-require 'tins/alias'

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

@@ -1,15 +0,0 @@
-module Tins
-  module ProcCompose
-    def compose(other)
-      self.class.new do |*args|
-        if other.respond_to?(:call)
-          call(*other.call(*args))
-        else
-          call(*other.to_proc.call(*args))
-        end
-      end
-    end
-
-    alias * compose
-  end
-end

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

@@ -1,73 +0,0 @@
-require 'tins/memoize'
-
-module Tins
-  module ProcPrelude
-    def apply(&my_proc)
-      my_proc or raise ArgumentError, 'a block argument is required'
-      lambda { |list| my_proc.call(*list) }
-    end
-
-    def map_apply(my_method, *args, &my_proc)
-      my_proc or raise ArgumentError, 'a block argument is required'
-      lambda { |x, y| my_proc.call(x, y.__send__(my_method, *args)) }
-    end
-
-    def call(obj, &my_proc)
-      my_proc or raise ArgumentError, 'a block argument is required'
-      obj.instance_eval(&my_proc)
-    end
-
-    def array
-      lambda { |*list| list }
-    end
-    memoize_function :array, :freeze =>  true
-
-    def first
-      lambda { |*list| list.first }
-    end
-    memoize_function :first, :freeze =>  true
-
-    alias head first
-
-    def second
-      lambda { |*list| list[1] }
-    end
-    memoize_function :second, :freeze =>  true
-
-    def tail
-      lambda { |*list| list[1..-1] }
-    end
-    memoize_function :tail, :freeze =>  true
-
-    def last
-      lambda { |*list| list.last }
-    end
-    memoize_function :last, :freeze =>  true
-
-    def rotate(n = 1)
-      lambda { |*list| list.rotate(n) }
-    end
-
-    alias swap rotate
-
-    def id1
-      lambda { |obj| obj }
-    end
-    memoize_function :id1, :freeze =>  true
-
-    def const(konst = nil, &my_proc)
-      konst ||= my_proc.call
-      lambda { |*_| konst }
-    end
-
-    def nth(n)
-      lambda { |*list| list[n] }
-    end
-
-    def from(&block)
-      my_method, binding = block.call, block.binding
-      my_self = eval 'self', binding
-      lambda { |*list| my_self.__send__(my_method, *list) }
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module Tins
-  module RangePlus
-    def +(other)
-      to_a + other.to_a
-    end
-  end
-end
-
-require 'tins/alias'

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

@@ -1,9 +0,0 @@
-module Tins
-  module RequireMaybe
-    def require_maybe(library)
-      require library
-    rescue LoadError => e
-      block_given? and yield e
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Tins
-  module Responding
-    def responding?(*method_names)
-      Class.new do
-        define_method(:to_s) do
-          "Responding to #{method_names * ', '}"
-        end
-
-        alias inspect to_s
-
-        define_method(:===) do |object|
-          method_names.all? do |method_name|
-            object.respond_to?(method_name)
-          end
-        end
-      end.new
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Tins
-  module Rotate
-    def rotate!(n = 1)
-      if n >= 0
-        n.times { push shift }
-      else
-        (-n).times { unshift pop }
-      end
-      self
-    end
-
-    def rotate(n = 1)
-      clone.rotate!(n)
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-module Tins
-  # A bit more versatile rounding for Ruby
-  module Round
-    def self.included(klass)
-      if klass.instance_method(:round)
-        klass.class_eval do
-          begin
-            alias_method :__old_round__, :round
-            remove_method :round
-          rescue NameError
-          end
-        end
-        super
-      else
-        raise NoMethodError, 'no round method found'
-      end
-    end
-
-    def round(places = nil)
-      if places == nil || places == 0
-        return __old_round__
-      elsif places.respond_to?(:to_int)
-        places = places.to_int
-      else
-        raise TypeError, "argument places has to be like an Integer"
-      end
-      if places < 0
-        max_places = -Math.log(self.abs + 1) / Math.log(10)
-        raise ArgumentError, "places has to be >= #{max_places.ceil}" if max_places > places
-      end
-      t = self
-      f = 10.0 ** places
-      t *= f
-      if t.infinite?
-        result = self
-      else
-        if t >= 0.0
-          t = (t + 0.5).floor
-        elsif t < 0.0
-          t = (t - 0.5).ceil
-        end
-        t /= f
-        result = t.nan? ? self : t
-      end
-      max_places and result = result.to_i # if places < 0
-      result
-    end
-  end
-end
-
-require 'tins/alias'