social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/term-ansicolor-1.2.2/lib/term/ansicolor/rgb_color_metrics.rb

@@ -1,161 +0,0 @@
-module Term
-  module ANSIColor
-    module RGBColorMetricsHelpers
-      module WeightedEuclideanDistance
-        def weighted_euclidean_distance_to(other, weights = [ 1.0 ] * values.size)
-          sum = 0.0
-          values.zip(other.values, weights) do |s, o, w|
-            sum += w * (s - o) ** 2
-          end
-          Math.sqrt(sum)
-        end
-      end
-
-      module NormalizeRGBTriple
-        private
-
-        def normalize(v)
-          v /= 255.0
-          if v <= 0.04045
-            v / 12
-          else
-            ( (v + 0.055) / 1.055) ** 2.4
-          end
-        end
-
-        def normalize_rgb_triple(rgb_triple)
-          [
-            rgb_triple.red,
-            rgb_triple.green,
-            rgb_triple.blue
-          ].map { |v| normalize(v) }
-        end
-      end
-    end
-
-    module RGBColorMetrics
-      def self.metric(name)
-        metric?(name) or raise ArgumentError, "unknown metric #{name.inspect}"
-      end
-
-      def self.metric?(name)
-        if const_defined?(name)
-          const_get name
-        end
-      end
-
-      def self.metrics
-        constants.map(&:to_sym)
-      end
-
-      # Implements color distance how the old greeks and most donkeys would…
-      module Euclidean
-        def self.distance(rgb1, rgb2)
-          rgb1.weighted_euclidean_distance_to rgb2
-        end
-      end
-
-      # Implements color distance the best way everybody knows…
-      module NTSC
-        def self.distance(rgb1, rgb2)
-          rgb1.weighted_euclidean_distance_to rgb2, [ 0.299, 0.587, 0.114 ]
-        end
-      end
-
-      # Implements color distance as given in:
-      #   http://www.compuphase.com/cmetric.htm
-      module CompuPhase
-        def self.distance(rgb1, rgb2)
-          rmean = (rgb1.red + rgb2.red) / 2
-          rgb1.weighted_euclidean_distance_to rgb2,
-              [ 2 + (rmean >> 8), 4, 2 + ((255 - rmean) >> 8) ]
-        end
-      end
-
-      module YUV
-        class YUVTriple < Struct.new(:y, :u, :v)
-          include RGBColorMetricsHelpers::WeightedEuclideanDistance
-
-          def self.from_rgb_triple(rgb_triple)
-            r, g, b = rgb_triple.red, rgb_triple.green, rgb_triple.blue
-            y = (0.299 * r + 0.587 * g + 0.114 * b).round
-            u = ((b - y) * 0.492).round
-            v = ((r - y) * 0.877).round
-            new(y, u, v)
-          end
-        end
-
-        def self.distance(rgb1, rgb2)
-          yuv1 = YUVTriple.from_rgb_triple(rgb1)
-          yuv2 = YUVTriple.from_rgb_triple(rgb2)
-          yuv1.weighted_euclidean_distance_to yuv2
-        end
-      end
-
-      module CIEXYZ
-        class CIEXYZTriple < Struct.new(:x, :y, :z)
-          include RGBColorMetricsHelpers::WeightedEuclideanDistance
-          extend RGBColorMetricsHelpers::NormalizeRGBTriple
-
-          def self.from_rgb_triple(rgb_triple)
-            r, g, b = normalize_rgb_triple rgb_triple
-
-            x =  0.436052025 * r + 0.385081593 * g + 0.143087414 * b
-            y =  0.222491598 * r + 0.71688606  * g + 0.060621486 * b
-            z =  0.013929122 * r + 0.097097002 * g + 0.71418547  * b
-
-            x *= 255
-            y *= 255
-            z *= 255
-
-            new(x.round, y.round, z.round)
-          end
-        end
-
-        def self.distance(rgb1, rgb2)
-          xyz1 = CIEXYZTriple.from_rgb_triple(rgb1)
-          xyz2 = CIEXYZTriple.from_rgb_triple(rgb2)
-          xyz1.weighted_euclidean_distance_to xyz2
-        end
-      end
-
-      module CIELab
-        class CIELabTriple < Struct.new(:l, :a, :b)
-          include RGBColorMetricsHelpers::WeightedEuclideanDistance
-          extend RGBColorMetricsHelpers::NormalizeRGBTriple
-
-          def self.from_rgb_triple(rgb_triple)
-            r, g, b = normalize_rgb_triple rgb_triple
-
-            x =  0.436052025 * r + 0.385081593 * g + 0.143087414 * b
-            y =  0.222491598 * r + 0.71688606  * g + 0.060621486 * b
-            z =  0.013929122 * r + 0.097097002 * g + 0.71418547  * b
-
-            xr = x / 0.964221
-            yr = y
-            zr = z / 0.825211
-
-            eps = 216.0 / 24389
-            k = 24389.0 / 27
-
-            fx = xr > eps ? xr ** (1.0 / 3) : (k * xr + 16) / 116
-            fy = yr > eps ? yr ** (1.0 / 3) : (k * yr + 16) / 116
-            fz = zr > eps ? zr ** (1.0 / 3) : (k * zr + 16) / 116
-
-            l = 2.55 * ((116 * fy) - 16)
-            a = 500 * (fx - fy)
-            b = 200 * (fy - fz)
-
-            new(l.round, a.round, b.round)
-          end
-        end
-
-        def self.distance(rgb1, rgb2)
-          lab1 = CIELabTriple.from_rgb_triple(rgb1)
-          lab2 = CIELabTriple.from_rgb_triple(rgb2)
-          lab1.weighted_euclidean_distance_to lab2
-        end
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/term-ansicolor-1.2.2/lib/term/ansicolor/rgb_triple.rb

@@ -1,121 +0,0 @@
-require 'term/ansicolor/rgb_color_metrics'
-
-module Term
-  module ANSIColor
-    class RGBTriple
-      include Term::ANSIColor::RGBColorMetricsHelpers::WeightedEuclideanDistance
-
-      def self.convert_value(color)
-        color.nil? and raise ArgumentError, "missing color value"
-        color = Integer(color)
-        (0..0xff) === color or raise ArgumentError,
-          "color value #{color.inspect} not between 0 and 255"
-        color
-      end
-
-      private_class_method :convert_value
-
-      def self.from_html(html)
-        case html
-        when /\A#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})\z/i
-          new(*$~.captures.map { |c| convert_value(c.to_i(16)) })
-        when /\A#([0-9a-f])([0-9a-f])([0-9a-f])\z/i
-          new(*$~.captures.map { |c| convert_value(c.to_i(16) << 4) })
-        end
-      end
-
-      def self.from_hash(options)
-        new(
-          convert_value(options[:red]),
-          convert_value(options[:green]),
-          convert_value(options[:blue])
-        )
-      end
-
-      def self.from_array(array)
-        new(*array)
-      end
-
-      def self.[](thing)
-        case
-        when thing.respond_to?(:to_rgb_triple) then thing
-        when thing.respond_to?(:to_ary)        then RGBTriple.from_array(thing.to_ary)
-        when thing.respond_to?(:to_str)        then RGBTriple.from_html(thing.to_str.sub(/\Aon_/, '')) # XXX somewhat hacky
-        when thing.respond_to?(:to_hash)       then RGBTriple.from_hash(thing.to_hash)
-        else raise ArgumentError, "cannot convert #{thing.inspect} into #{self}"
-        end
-      end
-
-      def initialize(red, green, blue)
-        @values = [ red, green, blue ]
-      end
-
-      def red
-        @values[0]
-      end
-
-      def green
-        @values[1]
-      end
-
-      def blue
-        @values[2]
-      end
-
-      def gray?
-        red != 0 && red != 0xff && red == green && green == blue && blue == red
-      end
-
-      def html
-        s = '#'
-        @values.each { |c| s << '%02x' % c }
-        s
-      end
-
-      def to_rgb_triple
-        self
-      end
-
-      attr_reader :values
-      protected :values
-
-      def to_a
-        @values.dup
-      end
-
-      def ==(other)
-        @values == other.values
-      end
-
-      def distance_to(other, options = {})
-        options[:metric] ||= RGBColorMetrics::CIELab
-        options[:metric].distance(self, other)
-      end
-
-      def initialize_copy(other)
-        r = super
-        other.instance_variable_set :@values, @values.dup
-        r
-      end
-
-      def gradient_to(other, options = {})
-        options[:steps] ||= 16
-        steps = options[:steps].to_i
-        steps < 2 and raise ArgumentError, 'at least 2 steps are required'
-        changes = other.values.zip(@values).map { |x, y| x - y }
-        current = self
-        gradient = [ current.dup ]
-        s = steps - 1
-        while s > 1
-          current = current.dup
-          gradient << current
-          3.times do |i|
-            current.values[i] += changes[i] / (steps - 1)
-          end
-          s -= 1
-        end
-        gradient << other
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/term-ansicolor-1.2.2/lib/term/ansicolor/version.rb

@@ -1,8 +0,0 @@
-module Term::ANSIColor
-  # Term::ANSIColor version
-  VERSION         = '1.2.2'
-  VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
-  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
-  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
-  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
-end

data/vendor/ruby/1.9.1/gems/term-ansicolor-1.2.2/term-ansicolor.gemspec

@@ -1,40 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = "term-ansicolor"
-  s.version = "1.2.2"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Florian Frank"]
-  s.date = "2013-05-30"
-  s.description = "This library uses ANSI escape sequences to control the attributes of terminal output"
-  s.email = "flori@ping.de"
-  s.executables = ["cdiff", "decolor", "colortab", "term_mandel", "term_display"]
-  s.extra_rdoc_files = ["README.rdoc", "lib/term/ansicolor.rb", "lib/term/ansicolor/attribute.rb", "lib/term/ansicolor/ppm_reader.rb", "lib/term/ansicolor/rgb_color_metrics.rb", "lib/term/ansicolor/rgb_triple.rb", "lib/term/ansicolor/version.rb"]
-  s.files = [".gitignore", ".travis.yml", "CHANGES", "COPYING", "Gemfile", "README.rdoc", "Rakefile", "VERSION", "bin/cdiff", "bin/colortab", "bin/decolor", "bin/term_display", "bin/term_mandel", "examples/ColorTest.gif", "examples/Mona_Lisa.jpg", "examples/Stilleben.jpg", "examples/example.rb", "examples/lambda-red-plain.ppm", "examples/lambda-red.png", "examples/lambda-red.ppm", "examples/pacman.jpg", "examples/smiley.png", "examples/wool.jpg", "lib/term/ansicolor.rb", "lib/term/ansicolor/.keep", "lib/term/ansicolor/attribute.rb", "lib/term/ansicolor/ppm_reader.rb", "lib/term/ansicolor/rgb_color_metrics.rb", "lib/term/ansicolor/rgb_triple.rb", "lib/term/ansicolor/version.rb", "term-ansicolor.gemspec", "tests/ansicolor_test.rb", "tests/attribute_test.rb", "tests/ppm_reader_test.rb", "tests/rgb_color_metrics_test.rb", "tests/rgb_triple_test.rb", "tests/test_helper.rb"]
-  s.homepage = "http://flori.github.com/term-ansicolor"
-  s.licenses = ["GPL-2"]
-  s.rdoc_options = ["--title", "Term-ansicolor - Ruby library that colors strings using ANSI escape sequences", "--main", "README.rdoc"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "2.0.3"
-  s.summary = "Ruby library that colors strings using ANSI escape sequences"
-  s.test_files = ["tests/ansicolor_test.rb", "tests/attribute_test.rb", "tests/ppm_reader_test.rb", "tests/rgb_color_metrics_test.rb", "tests/rgb_triple_test.rb", "tests/test_helper.rb"]
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<gem_hadar>, ["~> 0.3.2"])
-      s.add_development_dependency(%q<simplecov>, [">= 0"])
-      s.add_runtime_dependency(%q<tins>, ["~> 0.8"])
-    else
-      s.add_dependency(%q<gem_hadar>, ["~> 0.3.2"])
-      s.add_dependency(%q<simplecov>, [">= 0"])
-      s.add_dependency(%q<tins>, ["~> 0.8"])
-    end
-  else
-    s.add_dependency(%q<gem_hadar>, ["~> 0.3.2"])
-    s.add_dependency(%q<simplecov>, [">= 0"])
-    s.add_dependency(%q<tins>, ["~> 0.8"])
-  end
-end

data/vendor/ruby/1.9.1/gems/term-ansicolor-1.2.2/tests/ansicolor_test.rb

@@ -1,133 +0,0 @@
-require 'test_helper'
-
-class String
-  include Term::ANSIColor
-end
-
-class Color
-  extend Term::ANSIColor
-end
-
-class StringLike
-  def initialize(string)
-    @string = string
-  end
-
-  def to_str
-    @string
-  end
-end
-
-class ANSIColorTest < Test::Unit::TestCase
-  include Term::ANSIColor
-
-  def setup
-    @string = "red"
-    @string_red = "\e[31mred\e[0m"
-    @string_red_on_green = "\e[42m\e[31mred\e[0m\e[0m"
-    @string_like = StringLike.new(@string)
-    @string_like_red = StringLike.new(@string_red)
-  end
-
-  attr_reader :string, :string_red, :string_red_on_green, :string_like, :string_like_red
-
-  def test_red
-    assert_equal string_red, string.red
-    assert_equal string_red, Color.red(string)
-    assert_equal string_red, Color.red { string }
-    assert_equal string_red, Term::ANSIColor.red { string }
-    assert_equal string_red, red { string }
-  end
-
-  def test_red_on_green
-    assert_equal string_red_on_green, string.red.on_green
-    assert_equal string_red_on_green, Color.on_green(Color.red(string))
-    assert_equal string_red_on_green, Color.on_green { Color.red { string } }
-    assert_equal string_red_on_green,
-      Term::ANSIColor.on_green { Term::ANSIColor.red { string } }
-    assert_equal string_red_on_green, on_green { red { string } }
-  end
-
-  def test_color
-    assert_equal "\e[38;5;128mfoo\e[0m", Color.color(:color128, "foo")
-    assert_equal "\e[38;5;128mfoo\e[0m", "foo".color(:color128)
-    assert_equal "\e[38;5;128mfoo\e[0m", color(:color128, "foo")
-    assert_equal "\e[38;5;128mfoo\e[0m", Color.color(:color128) { "foo" }
-    assert_equal "\e[38;5;128mfoo\e[0m", "foo".color(:color128) { "foo" }
-    assert_equal "\e[38;5;128mfoo\e[0m", color(:color128) { "foo" }
-    assert_equal "\e[38;5;128mfoo\e[0m", color(:color128) + "foo" + color(:reset)
-    assert_equal "\e[38;5;128mfoo\e[0m", Color.color(128, "foo")
-    assert_equal "\e[38;5;128mfoo\e[0m", "foo".color(128)
-    assert_equal "\e[38;5;128mfoo\e[0m", color(128, "foo")
-    assert_equal "\e[38;5;128mfoo\e[0m", Color.color(128) { "foo" }
-    assert_equal "\e[38;5;128mfoo\e[0m", "foo".color(128) { "foo" }
-    assert_equal "\e[38;5;128mfoo\e[0m", color(128) { "foo" }
-    assert_equal "\e[38;5;128mfoo\e[0m", color(128) + "foo" + color(:reset)
-  end
-
-  def test_on_color
-    assert_equal "\e[48;5;128mfoo\e[0m", Color.on_color(:color128, "foo")
-    assert_equal "\e[48;5;128mfoo\e[0m", "foo".on_color(:color128)
-    assert_equal "\e[48;5;128mfoo\e[0m", on_color(:color128, "foo")
-    assert_equal "\e[48;5;128mfoo\e[0m", Color.on_color(:color128) { "foo" }
-    assert_equal "\e[48;5;128mfoo\e[0m", "foo".on_color(:color128) { "foo" }
-    assert_equal "\e[48;5;128mfoo\e[0m", on_color(:color128) { "foo" }
-    assert_equal "\e[48;5;128mfoo\e[0m", on_color(:color128) + "foo" + color(:reset)
-    assert_equal "\e[48;5;128mfoo\e[0m", Color.on_color(128, "foo")
-    assert_equal "\e[48;5;128mfoo\e[0m", "foo".on_color(128)
-    assert_equal "\e[48;5;128mfoo\e[0m", on_color(128, "foo")
-    assert_equal "\e[48;5;128mfoo\e[0m", Color.on_color(128) { "foo" }
-    assert_equal "\e[48;5;128mfoo\e[0m", "foo".on_color(128) { "foo" }
-    assert_equal "\e[48;5;128mfoo\e[0m", on_color(128) { "foo" }
-    assert_equal "\e[48;5;128mfoo\e[0m", on_color(128) + "foo" + color(:reset)
-  end
-
-  def test_uncolor
-    assert_equal string, string_red.uncolor
-    assert_equal string, Color.uncolor(string_red)
-    assert_equal string, Color.uncolor(string_like_red)
-    assert_equal string, Color.uncolor { string_red }
-    assert_equal string, Color.uncolor { string_like_red }
-    assert_equal string, Term::ANSIColor.uncolor { string_red }
-    assert_equal string, Term::ANSIColor.uncolor { string_like_red }
-    assert_equal string, uncolor { string }
-    assert_equal string, uncolor { string_like_red }
-    assert_equal "", uncolor(Object.new)
-    for index in 0..255
-      assert_equal "foo", Color.uncolor(Color.color("color#{index}", "foo"))
-      assert_equal "foo", Color.uncolor(Color.on_color("color#{index}", "foo"))
-    end
-  end
-
-  def test_attributes
-    foo = 'foo'
-    for a in Term::ANSIColor.attributes
-      # skip clear for Ruby 1.9 which implements String#clear to empty the string
-      if a != :clear || Term::ANSIColor.support?(:clear)
-        assert_not_equal foo, foo_colored = foo.__send__(a)
-        assert_equal foo, foo_colored.uncolor
-      end
-      assert_not_equal foo, foo_colored = Color.__send__(a, foo)
-      assert_equal foo, Color.uncolor(foo_colored)
-      assert_not_equal foo, foo_colored = Color.__send__(a) { foo }
-      assert_equal foo, Color.uncolor { foo_colored }
-      assert_not_equal foo, foo_colored = Term::ANSIColor.__send__(a) { foo }
-      assert_equal foo, Term::ANSIColor.uncolor { foo_colored }
-      assert_not_equal foo, foo_colored = __send__(a) { foo }
-      assert_equal foo, uncolor { foo_colored }
-    end
-    assert_equal Term::ANSIColor.attributes, 'foo'.attributes
-  end
-
-  def test_coloring_string_like
-    assert_equal "\e[31mred\e[0m", red(string_like)
-  end
-
-  def test_frozen
-    string = 'foo'
-    red = string.red
-    string.extend(Term::ANSIColor).freeze
-    assert string.frozen?
-    assert_equal red, string.red
-  end
-end