share_counts 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    share_counts (0.0.1)
+      json
+      nokogiri
+      redis
+      rest-client
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ansi (1.2.2)
+    json (1.5.1)
+    mime-types (1.16)
+    minitest (2.0.2)
+    nokogiri (1.4.4)
+    redis (2.1.1)
+    rest-client (1.6.1)
+      mime-types (>= 1.16)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ansi
+  json
+  minitest
+  nokogiri
+  redis
+  rest-client
+  share_counts!

data/README.rdoc

@@ -0,0 +1,173 @@
+= Share Counts
+
+This gem makes it super easy to check how many times a page/URL has been shared on social networks and aggregators.
+It also supports caching with Redis both to speed things up and to reduce the risk of problems with API rate limits.
+
+Services currently supported:
+
+* Reddit
+* Digg
+* Twitter
+* Facebook (Share * Like)
+* LinkedIn
+* Google Buzz
+* StumbleUpon
+
+
+== Installation
+
+Just..
+	gem install share_counts
+
+and then require/bundle it.
+
+== Basic Usage
+
+You can check each service individually...
+
+	ruby-1.9.2-p0 :001 > require "share_counts"
+	 => true 
+	
+	ruby-1.9.2-p0 :002 > url = "http://vitobotta.com/awesomeprint-similar-production/"
+	 => "http://vitobotta.com/awesomeprint-similar-production/" 
+	
+	# Reddit
+	ruby-1.9.2-p0 :003 > ShareCounts.reddit url
+	 => 5 
+	
+	# Digg
+	ruby-1.9.2-p0 :004 > ShareCounts.digg url
+	 => 1 
+	
+	# Twitter
+	ruby-1.9.2-p0 :005 > ShareCounts.twitter url
+	 => 2 
+	
+	# Facebook shares
+	ruby-1.9.2-p0 :006 > ShareCounts.facebook url
+	 => 1 
+	
+	# Facebook likes
+	ruby-1.9.2-p0 :007 > ShareCounts.fblike url
+	 => 0 
+	
+	# LinkedIn
+	ruby-1.9.2-p0 :008 > ShareCounts.linkedin url
+	 => 2 
+	
+	# StumbleUpon
+	ruby-1.9.2-p0 :009 > ShareCounts.stumbleupon url
+	 => 0 
+	
+	# Google Buzz
+	ruby-1.9.2-p0 :010 > ShareCounts.googlebuzz url
+	 => 0 
+
+
+or you can get 'em all in one shot:
+
+	ruby-1.9.2-p0 :017 > ShareCounts.all "http://vitobotta.com/awesomeprint-similar-production/"
+	 => {:reddit=>5, :digg=>1, :twitter=>2, :facebook=>1, :fblike=>0, :linkedin=>2, :googlebuzz=>0, :stumbleupon=>0}
+
+
+Additionally, for Facebook you can get shares and likes at once:
+
+	ruby-1.9.2-p0 :018 > ShareCounts.fball "http://vitobotta.com/awesomeprint-similar-production/"
+	 => {"share_count"=>1, "like_count"=>0}
+
+
+You can also specify which networks you want to query at once:
+
+	ruby-1.9.2-p0 :004 > ShareCounts.selected "http://vitobotta.com/awesomeprint-similar-production/", [:reddit, :twitter]
+	 => {:reddit=>5, :twitter=>2}
+
+Sometimes APIs may not be available or may be having issues (or there's some rate limit and you are making too many requests in a short time). When something goes wrong while querying a service, even for a max of 3 attempts, the share count for that service is left as set to nil. This way you can easily know whether a share count could be obtained or updated for a given URL, but simply checking if the share count is nil.
+
+	ruby-1.9.2-p0 :002 > ShareCounts.selected "http://vitobotta.com/awesomeprint-similar-production/", [:reddit, :twitter]
+	Making request to reddit...
+	Failed 1 attempt(s)
+	Failed 2 attempt(s)
+	Failed 3 attempt(s)
+	Something went wrong with reddit: can't convert nil into String
+	Making request to twitter...
+	 => {:reddit=>nil, :twitter=>2}
+
+
+== Caching
+
+Depending on how and in which kind of applications you may want to use this gem, if you make too many requests in a short time some APIs may fail because of rate limits. Plus, some API may respond too slowly at times or just be down (Digg seems to be the least reliable of the group so far!). So the gem also supports caching, at the moment with Redis only. 
+
+It's very easy to enable and use the caching:
+
+	ruby-1.9.2-p0 :002 > require 'benchmark'
+	 => true 
+
+	# Enabling caching
+	ruby-1.9.2-p0 :003 > ShareCounts.use_cache
+	 => #<Redis client v2.1.1 connected to redis://127.0.0.1:6379/0 (Redis v2.0.3)> 
+
+
+	# First run, values are not cached
+	ruby-1.9.2-p0 :004 > Benchmark.realtime { ShareCounts.all "http://vitobotta.com/awesomeprint-similar-production/" }
+	Making request to reddit...
+	Making request to digg...
+	Making request to twitter...
+	Making request to facebook...
+	Making request to fblike...
+	Making request to linkedin...
+	Making request to googlebuzz...
+	Making request to stumbleupon...
+	 => 3.7037899494171143 
+
+
+	# Now values are cached
+	ruby-1.9.2-p0 :005 > Benchmark.realtime { ShareCounts.all "http://vitobotta.com/awesomeprint-similar-production/" }
+	Loaded reddit count from cache
+	Loaded digg count from cache
+	Loaded twitter count from cache
+	Loaded facebook count from cache
+	Loaded fblike count from cache
+	Loaded linkedin count from cache
+	Loaded googlebuzz count from cache
+	Loaded stumbleupon count from cache
+	 => 0.003225088119506836
+
+
+By default, the gem connects to the Redis store listening on 127.0.0.1:6379, but you can override these settings when you enable the caching:
+
+	ruby-1.9.2-p0 :002 > ShareCounts.use_cache :host => "192.168.10.85", :port => 7500
+	 => #<Redis client v2.1.1 connected to redis://192.168.10.85:7500/0 (Redis v2.0.3)>	
+
+Or, if you are already using the "redis" gem in your application and therefore already have initialised a connection to the Redis store, you can either pass the reference to that instance:
+
+	ruby-1.9.2-p0 :003 > ShareCounts.use_cache :redis_store => YOUR_REFERENCE_TO_REDIS_STORE
+	 => #<Redis client v2.1.1 connected to redis://127.0.0.1:6379/0 (Redis v2.0.3)>
+
+or just set the global variable $share_counts_cache to that reference.
+
+Similarly, by default cached share counts expire in two minutes, but you can override this by setting the global variable $share_counts_cache_expire (in seconds).
+
+You can also get an hash having all the cached URLs with their share counts:
+
+	ruby-1.9.2-p0 :009 > ShareCounts.cached
+	 => {"http://vitobotta.com/awesomeprint-similar-production/"=>{:fblike=>0, :stumbleupon=>0, :linkedin=>2, :googlebuzz=>0, :facebook=>1, :twitter=>2, :digg=>1, :reddit=>5}}
+
+
+And, if needed, your can clear the cached values:
+
+	ruby-1.9.2-p0 :010 > ShareCounts.clear_cache
+	 => ["ShareCounts||fblike||http://vitobotta.com/awesomeprint-similar-production/", "ShareCounts||stumbleupon||http://vitobotta.com/awesomeprint-similar-production/", "ShareCounts||linkedin||http://vitobotta.com/awesomeprint-similar-production/", "ShareCounts||googlebuzz||http://vitobotta.com/awesomeprint-similar-production/", "ShareCounts||facebook||http://vitobotta.com/awesomeprint-similar-production/", "ShareCounts||twitter||http://vitobotta.com/awesomeprint-similar-production/", "ShareCounts||digg||http://vitobotta.com/awesomeprint-similar-production/", "ShareCounts||reddit||http://vitobotta.com/awesomeprint-similar-production/"] 
+	ruby-1.9.2-p0 :011 > ShareCounts.cached
+	 => {
+
+However the gem will namespace all the keys as you can see, in case you also use Redis for something else in the same app.
+
+== TODO
+
+* specs
+
+
+== Authors
+
+* Vito Botta ( http://vitobotta.com )
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/share_counts/caching.rb

@@ -0,0 +1,110 @@
+module ShareCountsCaching
+  
+  # 
+  # 
+  # Returns true if the Redis
+  # cache store has been initialised
+  # 
+  # 
+  def cache_enabled?
+    !$share_counts_cache.nil?
+  end
+
+
+
+  # 
+  # 
+  # Removes from Redis cache store all the keys 
+  # used by ShareCounts.
+  # 
+  # 
+  def clear_cache
+    ($share_counts_cache || {}).keys.select{|cache_key| cache_key =~ /^ShareCounts/ }.each{|cache_key| 
+      $share_counts_cache.del cache_key}
+  end
+  
+  
+  # 
+  # 
+  # Returns the cached share counts available for each URL, in the format
+  # 
+  # { 
+  #   "URL 1": {
+  #     :reddit      => N, 
+  #     :digg        => N, 
+  #     :twitter     => N, 
+  #     :facebook    => N, 
+  #     :fblike      => N, 
+  #     :linkedin    => N, 
+  #     :googlebuzz  => N, 
+  #     :stumbleupon => N
+  #   },
+  #   
+  #   "URL 2": {
+  #     ...
+  #   }
+  # }
+  # 
+  # 
+  def cached
+    urls = ($share_counts_cache || {}).keys.select{|k| k =~ /^ShareCounts/ }.inject({}) do |result, key|
+      data = key.split("||"); network = data[1]; url = data[2]; 
+      count = from_redis("ShareCounts||#{network}||#{url}")
+      (result[url] ||= {})[network.to_sym] = count unless ["all", "fball"].include? network
+      result
+    end
+    urls
+  end
+  
+  # 
+  # 
+  # Enables caching with Redis. 
+  # 
+  # By default, it connects to 127.0.0.1:6379, but it is also
+  # possible to specify in the arguments :host, :port the
+  # connection details.
+  # 
+  # If the application using this gem is already using Redis too,
+  # with the "redis" gem, it is possible to use the existing 
+  # instance of Redis by either setting the :redist_store argument
+  # or by setting the global variable $share_counts_cache first.
+  # 
+  # 
+  def use_cache *args
+    arguments = args.inject({}) { |r, c| r.merge(c) }
+    $share_counts_cache ||= arguments[:redis_store] || 
+      Redis.new(:host => arguments[:host] || "127.0.0.1", :port => arguments[:port] || "6379")  
+  end
+
+
+  private 
+  
+  # 
+  # 
+  # Caches the given value in Redis under the key specified.
+  # By default the value is cached for two minutes, but it
+  # is also possible to override this expiration time by 
+  # setting the global variable $share_counts_cache_expire 
+  # to a number of seconds.
+  # 
+  # 
+  def to_redis(cache_key, value)
+    $share_counts_cache.set cache_key, Marshal.dump(value)
+    $share_counts_cache.expire cache_key, $share_counts_cache_expire || 120
+    value
+  end
+
+  
+  # 
+  # 
+  # Retrieves the value stores in Redis under 
+  # the given key.
+  # 
+  # 
+  def from_redis(cache_key)
+    value = $share_counts_cache.get(cache_key)
+    return if value.nil?
+    Marshal.load value
+  end
+  
+end

data/lib/share_counts/common.rb

@@ -0,0 +1,106 @@
+module ShareCountsCommon
+
+  private
+  
+  # 
+  # 
+  # Given the name of one of the supported social networks and a URL,
+  # attempts the execution of the given block to fetch the relevant share count.
+  # 
+  # If caching with Redis is enabled, it will first try to 
+  # fetch the share count from cache instead, if there is a valid 
+  # cached value for the combination of network/URL. When a share count is 
+  # instead retrieved with an HTTP request to the network's API and 
+  # the caching with Redis is enabled, the value fetched is also cached.
+  # 
+  # NOTE: caching will be skipped if the block fails.
+  # 
+  # 
+  def try service, url, &block
+    cache_key = "ShareCounts||#{service}||#{url}"
+    if cache_enabled?
+      if result = from_redis(cache_key)
+        puts "Loaded #{service} count from cache"
+        result
+      else
+        puts "Making request to #{service}..."
+        to_redis(cache_key, yield)
+      end
+    else
+      puts "Redis caching is disabled - Making request to #{service}..."
+      yield
+    end
+  rescue Exception => e
+    puts "Something went wrong with #{service}: #{e}"
+  end
+
+
+  # 
+  # 
+  # Performs an HTTP request to the given API URL with the specified params
+  # and within 2 seconds, and max 3 attempts
+  # 
+  # If a :callback param is also specified, then it is assumed that the API
+  # returns a JSON text wrapped in a call to a method by that callback name,
+  # therefore in this case it manipulates the response to extract only
+  # the JSON data required.
+  # 
+  def make_request *args
+    result   = nil
+    attempts = 1
+
+    begin
+      timeout(2) do
+        url         = args.shift
+        params      = args.inject({}) { |r, c| r.merge! c }
+        response    = RestClient.get url,  { :params => params }
+
+
+        # if a callback is specified, the expected response is in the format "callback_name(JSON data)";
+        # with the response ending with ";" and, in some cases, "\n"
+        result = params.keys.include?(:callback) \
+          ? response.gsub(/^(.*);+\n*$/, "\\1").gsub(/^#{params[:callback]}\((.*)\)$/, "\\1") \
+          : response
+      end
+      
+    rescue Exception => e
+      puts "Failed #{attempts} attempt(s)"
+      attempts += 1
+      retry if attempts <= 3
+    end
+    
+    result
+  end
+
+
+  # 
+  # 
+  # Makes an HTTP request with the given URL and params, and assumes 
+  # that the response is in JSON format, therefore it returns
+  # the parsed JSON.
+  # 
+  # 
+  def from_json *args
+    JSON.parse make_request *args
+  end
+
+  # 
+  # 
+  # Most social networks' APIs returns normal JSON data;
+  # this method simply extracts directly the share count from
+  # the given JSON data, by following a pattern common to the
+  # structure of most JSON responses.
+  # 
+  # It also requires a :selector argument that determines how
+  # to "query" the JSON data in a way that emulates XPATH,
+  # so to extract the share count.
+  # 
+  # 
+  def extract_count *args
+    json = args.shift
+    result = args.first.flatten.last.split("/").inject( json.is_a?(Array) ? json.first : json ) { 
+      |r, c| r[c].is_a?(Array) ? r[c].first : r[c] 
+    }
+  end
+
+end

data/lib/share_counts.rb

@@ -0,0 +1,90 @@
+%w(rest_client json nokogiri redis timeout).each{|x| require x}
+
+require File.expand_path(File.dirname(__FILE__) + "/share_counts/common")
+require File.expand_path(File.dirname(__FILE__) + "/share_counts/caching")
+
+module ShareCounts
+
+  extend ShareCountsCommon
+  extend ShareCountsCaching
+
+  def self.supported_networks
+    %w(reddit digg twitter facebook fblike linkedin googlebuzz stumbleupon)
+  end
+
+  def self.reddit url
+    try("reddit", url) {
+      extract_count from_json( "http://www.reddit.com/api/info.json", :url => url ), 
+        :selector => "data/children/data/score" 
+    }
+  end
+
+  def self.digg url
+    try("digg", url) {
+      extract_count from_json( "http://services.digg.com/2.0/story.getInfo", :links => url ), 
+        :selector => "stories/diggs"
+    }
+  end
+
+  def self.twitter url
+    try("twitter", url) {
+      extract_count from_json( "http://urls.api.twitter.com/1/urls/count.json", :url => url, :callback => "x" ), 
+        :selector => "count"
+    }
+  end
+
+  def self.facebook url
+    try("facebook", url) {
+      extract_count from_json("http://api.facebook.com/restserver.php", :v => "1.0", :method => "links.getStats",  
+       :urls => url, :callback => "fb_sharepro_render", :format => "json" ), :selector => "share_count"
+    }
+  end
+
+  def self.fblike url
+    try("fblike", url) {
+      extract_count from_json("http://api.facebook.com/restserver.php", :v => "1.0", :method => "links.getStats",  
+       :urls => url, :callback => "fb_sharepro_render", :format => "json" ), :selector => "like_count"
+    }
+  end
+
+  def self.fball url 
+    try("fball", url) {
+      json = from_json("http://api.facebook.com/restserver.php", :v => "1.0", 
+          :method => "links.getStats", :urls => url, :callback => "fb_sharepro_render", :format => "json" 
+       ).first.select{ |k,v| ["share_count", "like_count"].include? k }
+    }
+  end
+
+  def self.linkedin url 
+    try("linkedin", url) {
+      extract_count from_json("http://www.linkedin.com/cws/share-count", 
+        :url => url, :callback => "IN.Tags.Share.handleCount" ), :selector => "count"
+    }
+  end
+
+  def self.googlebuzz url 
+    try("googlebuzz", url) {
+      from_json("http://www.google.com/buzz/api/buzzThis/buzzCounter", 
+        :url => url, :callback => "google_buzz_set_count" )[url]
+    }
+  end
+
+  def self.stumbleupon url 
+    try("stumbleupon", url) {
+      Nokogiri::HTML.parse( 
+          make_request("http://www.stumbleupon.com/badge/embed/5/", :url => url ) 
+        ).xpath( "//body/div/ul/li[2]/a/span").text.to_i
+    }
+  end
+
+  def self.all url
+    supported_networks.inject({}) { |r, c| r[c.to_sym] = ShareCounts.send(c, url); r }
+  end
+
+  def self.selected url, selections
+    selections.map{|name| name.downcase}.select{|name| supported_networks.include? name.to_s}.inject({}) {
+       |r, c| r[c.to_sym] = ShareCounts.send(c, url); r }
+  end
+
+end
+

data/share_counts.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+$:.push File.expand_path("../lib/share_counts", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "share_counts"
+  s.version     = "0.0.2"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Vito Botta"]
+  s.email       = ["vito@botta.name"]
+  s.homepage    = "https://github.com/vitobotta/share_counts"
+  s.summary     = %q{The easiest way to check how many times a URL has been shared on Reddit, Digg, Twitter, Facebook, LinkedIn, GoogleBuzz and StumbleUpon!}
+  s.description = %q{The easiest way to check how many times a URL has been shared on Reddit, Digg, Twitter, Facebook, LinkedIn, GoogleBuzz and StumbleUpon!}
+
+  s.add_dependency "rest-client"
+  s.add_dependency "json"
+  s.add_dependency "nokogiri"
+  s.add_dependency "redis"
+
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "ansi"
+  
+  s.rubyforge_project = "share_counts"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/share_count_spec.rb

@@ -0,0 +1,3 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+
+# nothing in here yet!

data/spec/test_helper.rb

@@ -0,0 +1,157 @@
+require 'rubygems'
+gem "minitest"
+require 'minitest/autorun'
+
+require 'ansi'
+
+class MiniTest::Unit
+  include ANSI::Code
+
+  PADDING_SIZE = 4
+
+  def run(args = [])
+    @verbose = true
+
+    filter = if args.first =~ /^(-n|--name)$/ then
+               args.shift
+               arg = args.shift
+               arg =~ /\/(.*)\// ? Regexp.new($1) : arg
+             else
+               /./ # anything - ^test_ already filtered by #tests
+             end
+
+    @@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
+
+    start = Time.now
+    run_test_suites filter
+
+    @@out.puts
+    @@out.puts "Finished in #{'%.6f' % (Time.now - start)} seconds."
+
+    @@out.puts
+
+    @@out.print "%d tests, " % test_count
+    @@out.print "%d assertions, " % assertion_count
+    @@out.print red { "%d failures, " % failures }
+    @@out.print yellow { "%d errors, " % errors }
+    @@out.puts cyan { "%d skips" % skips}
+
+    return failures + errors if @test_count > 0 # or return nil...
+  end
+
+  # Overwrite #run_test_suites so that it prints out reports
+  # as errors are generated.
+  def run_test_suites(filter = /./)
+    @test_count, @assertion_count = 0, 0
+    old_sync, @@out.sync = @@out.sync, true if @@out.respond_to? :sync=
+
+    TestCase.test_suites.each do |suite|
+      test_cases = suite.test_methods.grep(filter)
+      if test_cases.size > 0
+        @@out.print "\n#{suite}:\n"
+      end
+
+  test_cases.each do |test|
+        inst = suite.new test
+        inst._assertions = 0
+
+        t = Time.now
+
+        @broken = nil
+
+        @@out.print(case inst.run(self)
+                    when :pass
+                      @broken = false
+                      green { pad_with_size "PASS" }
+                    when :error
+                      @broken = true
+                      yellow { pad_with_size "ERROR" }
+                    when :fail
+                      @broken = true
+                      red { pad_with_size "FAIL" }
+                    when :skip
+                      @broken = false
+                      cyan { pad_with_size "SKIP" }
+                    end)
+
+
+        # @@out.print " #{test.humanize.gsub(/Test\s\d+\s(.*)/,"\\1")} "
+        @@out.print " #{test} "
+        @@out.print " (%.2fs) " % (Time.now - t)
+
+        if @broken
+          @@out.puts 
+
+          report = @report.last
+          @@out.puts pad(report[:message], 10)
+          trace = MiniTest::filter_backtrace(report[:exception].backtrace).first
+          @@out.print pad(trace, 10)
+
+          @@out.puts
+        end
+
+        @@out.puts
+        @test_count += 1
+        @assertion_count += inst._assertions
+      end
+    end
+    @@out.sync = old_sync if @@out.respond_to? :sync=
+    [@test_count, @assertion_count]
+  end
+
+  def pad(str, size=PADDING_SIZE)
+    " " * size + str
+  end
+
+  def pad_with_size(str)
+    pad("%5s" % str)
+  end
+
+  # Overwrite #puke method so that is stores a hash
+  # with :message and :exception keys.
+  def puke(klass, meth, e)
+    result = nil
+    msg = case e
+        when MiniTest::Skip
+          @skips += 1
+          result = :skip
+          e.message
+        when MiniTest::Assertion
+          @failures += 1
+          result = :fail
+          e.message
+        else
+          @errors += 1
+          result = :error
+          "#{e.class}: #{e.message}\n"
+        end
+
+    @report << {:message => msg, :exception => e}
+    result
+  end
+
+
+  class TestCase
+    # Overwrite #run method so that is uses symbols
+    # as return values rather than characters.
+    def run(runner)
+      result = :pass
+      begin
+        @passed = nil
+        self.setup
+        self.send  self.__name__
+        @passed = true
+      rescue Exception => e
+        @passed = false
+        result = runner.puke(self.class, self.__name__, e)
+      ensure
+        begin
+          self.teardown
+        rescue Exception => e
+          result = runner.puke(self.class, self.__name__, e)
+        end
+      end
+      result
+    end
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification 
+name: share_counts
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Vito Botta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-30 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: ansi
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: The easiest way to check how many times a URL has been shared on Reddit, Digg, Twitter, Facebook, LinkedIn, GoogleBuzz and StumbleUpon!
+email: 
+- vito@botta.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- lib/share_counts.rb
+- lib/share_counts/caching.rb
+- lib/share_counts/common.rb
+- share_counts.gemspec
+- spec/share_count_spec.rb
+- spec/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/vitobotta/share_counts
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: share_counts
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: The easiest way to check how many times a URL has been shared on Reddit, Digg, Twitter, Facebook, LinkedIn, GoogleBuzz and StumbleUpon!
+test_files: 
+- spec/share_count_spec.rb
+- spec/test_helper.rb