social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/count_by_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-require 'tins/xt'
-
-module Tins
-  class CountByTest < Test::Unit::TestCase
-
-    def test_count_by
-      assert_equal 0, [].count_by { |x| x % 2 == 0 }
-      assert_equal 0, [ 1 ].count_by { |x| x % 2 == 0 }
-      assert_equal 1, [ 1 ].count_by { |x| x % 2 == 1 }
-      assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 0 }
-      assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 1 }
-      assert_equal 2, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 0 }
-      assert_equal 3, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 1 }
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/date_dummy_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-module Tins
-  class DateDummyTest < Test::Unit::TestCase
-    require 'tins/xt/date_dummy'
-    require 'date'
-
-    def test_date_dummy
-      date = Date.parse('2009-09-09')
-      assert_not_equal date, Date.today
-      Date.dummy = date
-      assert_equal date, Date.today
-      Date.dummy = nil
-      assert_not_equal date, Date.today
-    end
-
-    def test_date_dummy_block
-      date = Date.parse('2009-09-09')
-      assert_not_equal date, Date.today
-      Date.dummy date do
-        assert_equal date, Date.today
-        Date.dummy date + 1 do
-          assert_equal date + 1, Date.today
-        end
-        assert_equal date, Date.today
-      end
-      assert_not_equal date, Date.today
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/date_time_dummy_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-module Tins
-  class DateTimeDummyTest < Test::Unit::TestCase
-    require 'tins/xt/date_time_dummy'
-    require 'date'
-
-    def test_time_dummy
-      date_time = DateTime.parse('2009-09-09 21:09:09')
-      assert_not_equal date_time, DateTime.now
-      DateTime.dummy = date_time
-      assert_equal date_time, DateTime.now
-      DateTime.dummy = nil
-      assert_not_equal date_time, DateTime.now
-    end
-
-    def test_time_dummy_block
-      date_time = DateTime.parse('2009-09-09 21:09:09')
-      assert_not_equal date_time, DateTime.now
-      DateTime.dummy date_time do
-        assert_equal date_time, DateTime.now
-        DateTime.dummy date_time + 1 do
-          assert_equal date_time + 1, DateTime.now
-        end
-        assert_equal date_time, DateTime.now
-      end
-      assert_not_equal date_time, DateTime.now
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/deep_const_get_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-require 'tins/xt/deep_const_get'
-
-module Tins
-  class DeepConstGetTest < Test::Unit::TestCase
-    module A
-      module B
-      end
-    end
-
-    module C
-      module NotB
-      end
-
-      def self.const_missing(c)
-        NotB
-      end
-    end
-
-    def test_deep_const_get_with_start_module
-      assert_raise(ArgumentError) { deep_const_get '::B', A }
-      assert_equal A::B, deep_const_get('B', A)
-    end
-
-    def test_deep_const_get_without_start_module
-      assert_equal Tins::DeepConstGetTest::A::B, deep_const_get('::Tins::DeepConstGetTest::A::B')
-      assert_equal Tins::DeepConstGetTest::A::B, deep_const_get('Tins::DeepConstGetTest::A::B')
-      assert_equal Array, deep_const_get('::Array')
-      assert_equal Array, deep_const_get('Array')
-    end
-
-    def test_deep_const_get_with_const_missing
-      assert_raise(ArgumentError) { deep_const_get '::Tins::DeepConstGetTest::A::D' }
-      assert_equal Tins::DeepConstGetTest::C::NotB, deep_const_get('::Tins::DeepConstGetTest::C::B')
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/deep_dup_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-require 'tins/xt'
-
-module Tins
-  class DeepDupTest < Test::Unit::TestCase
-    def test_deep_dup
-      a = [1,2,3]
-      assert_equal    a, a.deep_dup
-      assert_not_same a, a.deep_dup
-    end
-
-    def test_deep_dup_proc
-      f = lambda { |x| 2 * x }
-      g = f.deep_dup
-      assert_equal f[3], g[3]
-      assert_equal f, g
-      assert_same  f, g
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/extract_last_argument_options_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-module Tins
-  class ExtractLastArgumentOptionsTest < Test::Unit::TestCase
-    require 'tins/xt/extract_last_argument_options'
-
-    def test_empty_argument_array
-      arguments = []
-      result = arguments.extract_last_argument_options
-      assert_equal [ [], {} ], result
-      assert_not_same arguments, result.first
-    end
-
-    def test_argument_array_without_options
-      arguments = [ 1, 2, 3 ]
-      result = arguments.extract_last_argument_options
-      assert_equal [ [ 1, 2, 3 ], {} ], result
-      assert_not_same arguments, result.first
-    end
-
-    def test_argument_array_witt_options
-      arguments = [ 1, 2, 3, { :foo => :bar } ]
-      result = arguments.extract_last_argument_options
-      assert_equal [ [ 1, 2, 3 ], { :foo => :bar } ], result
-      assert_not_same arguments, result.first
-      assert_not_same arguments.last, result.last
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/file_binary_test.rb

@@ -1,65 +0,0 @@
-require 'test_helper'
-require 'tempfile'
-require 'tins/xt'
-
-module Tins
-  class TinsFileBinaryTest < Test::Unit::TestCase
-    def test_ascii_buffer_size
-      write_file do |file|
-        file.write "A" * 10 + "\x00"
-        assert_equal true,  file.ascii?(:buffer_size => 10)
-        assert_equal true,  File.ascii?(file.path, :buffer_size => 10)
-        assert_equal false, file.binary?(:buffer_size => 10)
-        assert_equal false, File.binary?(file.path, :buffer_size => 10)
-      end
-    end
-
-    def test_binary
-      write_file do |file|
-        file.write "A" * 69 + "\x01" * 31
-        assert_equal true,  file.binary?
-        assert_equal true,  File.binary?(file.path)
-        assert_equal false, file.ascii?
-        assert_equal false, File.ascii?(file.path)
-      end
-    end
-
-    def test_ascii_offset
-      write_file do |file|
-        file.write "\x01" * 31 + "A" * 70
-        assert_equal false, file.binary?(:offset => 1)
-        assert_equal false, File.binary?(file.path, :offset => 1)
-        assert_equal true,  file.ascii?(:offset => 1)
-        assert_equal true,  File.ascii?(file.path, :offset => 1)
-      end
-    end
-
-    def test_binary_zero
-      write_file do |file|
-        file.write "A" * 50 + "\0"  + "A" * 49
-        assert_equal true,  file.binary?
-        assert_equal true,  File.binary?(file.path)
-        assert_equal false, file.ascii?
-        assert_equal false, File.ascii?(file.path)
-      end
-    end
-
-    def test_ascii
-      write_file do |file|
-        file.write "A" * 100
-        assert_equal false, file.binary?
-        assert_equal false, File.binary?(file.path)
-        assert_equal true,  file.ascii?
-        assert_equal true,  File.ascii?(file.path)
-      end
-    end
-
-    private
-
-    def write_file
-      File.open(File.join(Dir.tmpdir, "temp.#$$"), 'wb+') do |file|
-        yield file
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/find_test.rb

@@ -1,115 +0,0 @@
-require 'test_helper'
-require 'tins/find'
-require 'fileutils'
-require 'tempfile'
-
-module Tins
-  class FindTest < Test::Unit::TestCase
-    include Tins::Find
-    include FileUtils
-
-    def setup
-      mkdir_p @work_dir = File.join(Dir.tmpdir, "test.#$$")
-    end
-
-    def teardown
-      rm_rf @work_dir
-    end
-
-    def test_raising_errors
-      assert_equal [], find(File.join(@work_dir, 'nix'), :raise_errors => false).to_a
-      assert_equal [], find(File.join(@work_dir, 'nix')).to_a
-      assert_raise(Errno::ENOENT) do
-        find(File.join(@work_dir, 'nix'), :raise_errors => true).to_a
-      end
-    end
-
-    def test_showing_hidden
-      touch file = File.join(@work_dir, '.foo')
-      assert_equal [ @work_dir ], find(@work_dir, :show_hidden => false).to_a
-      assert_equal [ @work_dir, file ], find(@work_dir).to_a
-      assert_equal [ @work_dir, file ], find(@work_dir, :show_hidden => true).to_a
-    end
-
-    def test_check_directory_without_access
-      # do not run this test on JRuby
-      omit_if(RUBY_PLATFORM =~ /java/, "Can't run the test on JRuby")
-      # do not run this test if we're root, as it will fail.
-      omit_if(Process::UID.eid == 0, "Can't run the test as root")
-
-      begin
-        mkdir_p directory1 = File.join(@work_dir, 'foo')
-        mkdir_p directory2 = File.join(directory1, 'bar')
-        touch file = File.join(directory2, 'file')
-        chmod 0, directory2
-        assert_equal [ @work_dir, directory1, directory2 ], find(@work_dir, :raise_errors => false).to_a
-        assert_equal [ @work_dir, directory1, directory2 ], find(@work_dir).to_a
-        assert_raise(Errno::EACCES) do
-          find(@work_dir, :raise_errors => true).to_a
-        end
-      ensure
-        File.exist?(directory2) and chmod 0777, directory2
-      end
-    end
-
-    def test_follow_symlinks
-      mkdir_p directory1 = File.join(@work_dir, 'foo1')
-      mkdir_p directory2 = File.join(@work_dir, 'foo2')
-      mkdir_p directory3 = File.join(directory1, 'bar')
-      touch file = File.join(directory3, 'foo')
-      ln_s directory3, link = File.join(directory2, 'baz')
-      assert_equal [ directory2, link ], find(directory2, :follow_symlinks => false).to_a
-      assert_equal [ directory2, link, linked = File.join(link, 'foo') ], find(directory2).to_a
-      assert_equal [ directory2, link, linked ], find(directory2, :follow_symlinks => true).to_a
-    end
-
-    def test_path_file
-      File.open(File.join(@work_dir, 'foo'), 'w') do |f|
-        f.print "hello"
-        f.fsync
-        assert_equal "hello", find(@work_dir).select { |f| f.stat.file? }.first.file.read
-      end
-    end
-
-    def test_path_extension
-      finder = Tins::Find::Finder.new
-      f = File.open(path = File.join(@work_dir, 'foo.bar'), 'w')
-      ln_s path, path2 = File.join(@work_dir, 'foo2.bar')
-      path2 = finder.prepare_path path2
-      path = finder.prepare_path path
-      assert_true path.exist?
-      assert_true path.file?
-      assert_false path.directory?
-      assert_true finder.prepare_path(Dir.pwd).directory?
-      assert_equal Pathname.new(path), path.pathname
-      assert_equal 'bar', path.suffix
-      assert_true path2.lstat.symlink?
-    ensure
-      f and rm_f f.path
-    end
-
-    def test_suffix
-      finder = Tins::Find::Finder.new(:suffix => 'bar')
-      f = File.open(fpath = File.join(@work_dir, 'foo.bar'), 'w')
-      g = File.open(gpath = File.join(@work_dir, 'foo.baz'), 'w')
-      fpath = finder.prepare_path fpath
-      gpath = finder.prepare_path gpath
-      assert_true finder.visit_path?(fpath)
-      assert_false finder.visit_path?(gpath)
-      finder.suffix = nil
-      assert_true finder.visit_path?(fpath)
-      assert_true finder.visit_path?(gpath)
-    ensure
-      f and rm_f f.path
-      g and rm_f g.path
-    end
-
-    def test_prune
-      mkdir_p directory1 = File.join(@work_dir, 'foo1')
-      mkdir_p directory2 = File.join(@work_dir, 'foo2')
-      result = []
-      find(@work_dir) { |f| f =~ /foo2\z/ and prune; result << f }
-      assert_equal [ @work_dir, directory1 ], result
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/generator_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-require 'tins'
-
-module Tins
-  class GeneratorTest < Test::Unit::TestCase
-    def setup
-      @numeric = [ 1, 2, 3 ]
-      @string  = %w[a b c]
-      @chars   = 'abc'
-    end
-
-    def test_generator
-      g = Tins::Generator[@numeric, @string]
-      assert_equal 2, g.size
-      g.add_dimension(@chars, :each_byte)
-      assert_equal 3, g.size
-      assert_equal\
-        [[1, "a", 97],
-        [1, "a", 98],
-        [1, "a", 99],
-        [1, "b", 97],
-        [1, "b", 98],
-        [1, "b", 99],
-        [1, "c", 97],
-        [1, "c", 98],
-        [1, "c", 99],
-        [2, "a", 97],
-        [2, "a", 98],
-        [2, "a", 99],
-        [2, "b", 97],
-        [2, "b", 98],
-        [2, "b", 99],
-        [2, "c", 97],
-        [2, "c", 98],
-        [2, "c", 99],
-        [3, "a", 97],
-        [3, "a", 98],
-        [3, "a", 99],
-        [3, "b", 97],
-        [3, "b", 98],
-        [3, "b", 99],
-        [3, "c", 97],
-        [3, "c", 98],
-        [3, "c", 99]], g.to_a
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/go_test.rb

@@ -1,50 +0,0 @@
-require 'test_helper'
-require 'tins/go'
-
-module Tins
-  class GoTest < Test::Unit::TestCase
-    include Tins::GO
-
-
-    def test_empty_string
-      r = go '', args = %w[a b c]
-      assert_equal({}, r)
-      assert_equal %w[a b c], args
-    end
-
-    def test_empty_args
-      r = go 'ab:', args = []
-      assert_equal({ 'a' => false, 'b' => nil }, r)
-      assert_equal [], args
-    end
-
-    def test_simple
-      r = go 'ab:', args = %w[-b hello -a -c rest]
-      assert_equal({ 'a' => 1, 'b' => 'hello' }, r)
-      assert_equal %w[-c rest], args
-    end
-
-    def test_complex
-      r = go 'ab:', args = %w[-a -b hello -a -bworld -c rest]
-      assert_equal({ 'a' => 2, 'b' => 'hello' }, r)
-      assert_equal %w[hello world], r['b'].to_a
-      assert_equal %w[-c rest], args
-    end
-
-    def test_complex2
-      r = go 'ab:', args = %w[-b hello -aa -b world -c rest]
-      assert_equal({ 'a' => 2, 'b' => 'hello' }, r)
-      assert_equal %w[hello world], r['b'].to_a
-      assert_equal %w[-c rest], args
-    end
-
-    def test_complex_frozen
-      args = %w[-b hello -aa -b world -c rest]
-      args = args.map(&:freeze)
-      r = go 'ab:', args
-      assert_equal({ 'a' => 2, 'b' => 'hello' }, r)
-      assert_equal %w[hello world], r['b'].to_a
-      assert_equal %w[-c rest], args
-    end
-  end
-end