social_url_stats 0.0.1

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

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

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

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

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

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