gem-dependent 0.2.4 → 0.2.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: afc8028826702e46dc846ddaa1b6b5161449caf9
+  data.tar.gz: fee1b6005723a95e52eefcec2955179bf168273d
+SHA512:
+  metadata.gz: 2d4363c02e41b93aa50e4e98a8762ca4b9818320666daae587c3a9833e6483343dc0e0efc836dea71c0f5896ba3944f824e828dbe005200ef364ea119d1e00f2
+  data.tar.gz: 4df19254cc6abd8db0f0000d5e6600966d07c0fb543ac3f2db7f72d85731870d2710699eabbf1503ff8e58cb3d26033db7920e516791382b17feff3dc3d74cd6

checksums.yaml.gz.sig

@@ -0,0 +1 @@
+ �|���?���#�3�뛶���ދ��W�

data/lib/rubygems/commands/dependent_command.rb

@@ -16,13 +16,17 @@ class Gem::Commands::DependentCommand < Gem::Command
       options[:fetch_limit] = n
     end
 
-    add_option('--parallel N', Integer, 'Make N requests in parallel') do |n, _|
+    add_option('--parallel N', Integer, 'Make N requests in parallel (default 15)') do |n, _|
       options[:parallel] = n
     end
 
     add_option('--all-versions', 'Check against all versions of gems') do
       options[:all_versions] = true
     end
+
+    add_option('--type dependent_type', 'Only look for dependents matching the listed type(s) (default is runtime and development)') do |n, _|
+      options[:type] = n.to_s.split(',').map(&:to_sym)
+    end
   end
 
   def arguments

data/lib/rubygems/dependent.rb

@@ -23,7 +23,7 @@ module Gem
       end
       $stderr.print "\n" if options[:progress]
 
-      select_dependent(gems_and_dependencies, gem)
+      select_dependent(gems_and_dependencies, gem, options)
     end
 
     private
@@ -56,9 +56,10 @@ module Gem
       end
     end
 
-    def self.select_dependent(gems_and_dependencies, gem)
+    def self.select_dependent(gems_and_dependencies, gem, options={})
+      accepted_types = (options[:type] || [:development, :runtime])
       gems_and_dependencies.map do |name, version, dependencies|
-        matching_dependencies = dependencies.select{|d| d.name == gem } rescue []
+        matching_dependencies = dependencies.select{|d| d.name == gem && accepted_types.include?(d.type) } rescue []
         next if matching_dependencies.empty?
         [name, version, matching_dependencies]
       end.compact

data/lib/rubygems/dependent/parallel.rb

@@ -9,264 +9,357 @@ require 'rbconfig'
 module Gem;end
 class Gem::Dependent;end
 class Gem::Dependent::Parallel
-  VERSION = '0.5.8'
+  VERSION = "0.8.0"
 
-  def self.in_threads(options={:count => 2})
-    count, options = extract_count_from_options(options)
+  class DeadWorker < Exception
+  end
 
-    out = []
-    threads = []
+  class Break < Exception
+  end
 
-    count.times do |i|
-      threads[i] = Thread.new do
-        out[i] = yield(i)
+  class ExceptionWrapper
+    attr_reader :exception
+    def initialize(exception)
+      dumpable = Marshal.dump(exception) rescue nil
+      unless dumpable
+        exception = RuntimeError.new("Undumpable Exception -- #{exception.inspect}")
       end
+
+      @exception = exception
     end
+  end
 
-    wait_for_threads(threads)
+  class Worker
+    attr_reader :pid, :read, :write
+    def initialize(read, write, pid)
+      @read, @write, @pid = read, write, pid
+    end
 
-    out
-  end
+    def close_pipes
+      read.close
+      write.close
+    end
 
-  def self.in_processes(options = {}, &block)
-    count, options = extract_count_from_options(options)
-    count ||= processor_count
-    map(0...count, options.merge(:in_processes => count), &block)
-  end
+    def wait
+      Process.wait(pid)
+    rescue Interrupt
+      # process died
+    end
 
-  def self.each(array, options={}, &block)
-    map(array, options.merge(:preserve_results => false), &block)
-    array
-  end
+    def work(index)
+      begin
+        Marshal.dump(index, write)
+      rescue Errno::EPIPE
+        raise DeadWorker
+      end
 
-  def self.each_with_index(array, options={}, &block)
-    each(array, options.merge(:with_index => true), &block)
+      begin
+        Marshal.load(read)
+      rescue EOFError
+        raise Parallel::DeadWorker
+      end
+    end
   end
 
-  def self.map(array, options = {}, &block)
-    array = array.to_a # turn Range and other Enumerable-s into an Array
+  class << self
+    def in_threads(options={:count => 2})
+      count, options = extract_count_from_options(options)
 
-    if options[:in_threads]
-      method = :in_threads
-      size = options[method]
-    else
-      method = :in_processes
-      size = options[method] || processor_count
-    end
-    size = [array.size, size].min
+      out = []
+      threads = []
+
+      count.times do |i|
+        threads[i] = Thread.new do
+          out[i] = yield(i)
+        end
+      end
 
-    return work_direct(array, options, &block) if size == 0
+      kill_on_ctrl_c(threads) { wait_for_threads(threads) }
 
-    if method == :in_threads
-      work_in_threads(array, options.merge(:count => size), &block)
-    else
-      work_in_processes(array, options.merge(:count => size), &block)
+      out
     end
-  end
-
-  def self.map_with_index(array, options={}, &block)
-    map(array, options.merge(:with_index => true), &block)
-  end
 
-  def self.processor_count
-    case RbConfig::CONFIG['host_os']
-    when /darwin9/
-      `hwprefs cpu_count`.to_i
-    when /darwin/
-      (hwprefs_available? ? `hwprefs thread_count` : `sysctl -n hw.ncpu`).to_i
-    when /linux/
-      `grep -c processor /proc/cpuinfo`.to_i
-    when /freebsd/
-      `sysctl -n hw.ncpu`.to_i
-    when /mswin|mingw/
-      require 'win32ole'
-      wmi = WIN32OLE.connect("winmgmts://")
-      cpu = wmi.ExecQuery("select NumberOfLogicalProcessors from Win32_Processor")
-      cpu.to_enum.first.NumberOfLogicalProcessors
+    def in_processes(options = {}, &block)
+      count, options = extract_count_from_options(options)
+      count ||= processor_count
+      map(0...count, options.merge(:in_processes => count), &block)
     end
-  end
 
-  private
+    def each(array, options={}, &block)
+      map(array, options.merge(:preserve_results => false), &block)
+      array
+    end
 
-  def self.work_direct(array, options)
-    results = []
-    array.each_with_index do |e,i|
-      results << (options[:with_index] ? yield(e,i) : yield(e))
+    def each_with_index(array, options={}, &block)
+      each(array, options.merge(:with_index => true), &block)
     end
-    results
-  end
 
-  def self.hwprefs_available?
-    `which hwprefs` != ''
-  end
+    def map(array, options = {}, &block)
+      array = array.to_a # turn Range and other Enumerable-s into an Array
 
-  def self.work_in_threads(items, options, &block)
-    results = []
-    current = -1
-    exception = nil
+      if options[:in_threads]
+        method = :in_threads
+        size = options[method]
+      else
+        method = :in_processes
+        size = options[method] || processor_count
+      end
+      size = [array.size, size].min
 
-    in_threads(options[:count]) do
-      # as long as there are more items, work on one of them
-      loop do
-        break if exception
+      return work_direct(array, options, &block) if size == 0
 
-        index = Thread.exclusive{ current+=1 }
-        break if index >= items.size
+      if method == :in_threads
+        work_in_threads(array, options.merge(:count => size), &block)
+      else
+        work_in_processes(array, options.merge(:count => size), &block)
+      end
+    end
 
-        begin
-          results[index] = call_with_index(items, index, options, &block)
-        rescue Exception => e
-          exception = e
-          break
-        end
+    def map_with_index(array, options={}, &block)
+      map(array, options.merge(:with_index => true), &block)
+    end
+
+    def processor_count
+      @processor_count ||= case RbConfig::CONFIG['host_os']
+      when /darwin9/
+        `hwprefs cpu_count`.to_i
+      when /darwin/
+        (hwprefs_available? ? `hwprefs thread_count` : `sysctl -n hw.ncpu`).to_i
+      when /linux|cygwin/
+        `grep -c ^processor /proc/cpuinfo`.to_i
+      when /(net|open|free)bsd/
+        `sysctl -n hw.ncpu`.to_i
+      when /mswin|mingw/
+        require 'win32ole'
+        wmi = WIN32OLE.connect("winmgmts://")
+        cpu = wmi.ExecQuery("select NumberOfLogicalProcessors from Win32_Processor")
+        cpu.to_enum.first.NumberOfLogicalProcessors
+      when /solaris2/
+        `psrinfo -p`.to_i # this is physical cpus afaik
+      else
+        $stderr.puts "Unknown architecture ( #{RbConfig::CONFIG["host_os"]} ) assuming one processor."
+        1
       end
     end
 
-    raise exception if exception
+    def physical_processor_count
+      @physical_processor_count ||= begin
+        ppc = case RbConfig::CONFIG['host_os']
+        when /darwin1/, /freebsd/
+          `sysctl -n hw.physicalcpu`.to_i
+        when /linux/
+          cores_per_physical = `grep cores /proc/cpuinfo`[/\d+/].to_i
+          physicals = `grep 'physical id' /proc/cpuinfo |sort|uniq|wc -l`.to_i
+          physicals * cores_per_physical
+        when /mswin|mingw/
+          require 'win32ole'
+          wmi = WIN32OLE.connect("winmgmts://")
+          cpu = wmi.ExecQuery("select NumberOfProcessors from Win32_Processor")
+          cpu.to_enum.first.NumberOfLogicalProcessors
+        else
+          processor_count
+        end
+        # fall back to logical count if physical info is invalid
+        ppc > 0 ? ppc : processor_count
+      end
+    end
 
-    results
-  end
+    private
 
-  def self.work_in_processes(items, options, &blk)
-    current_index = -1
-    results = []
-    pids = []
-    exception = nil
+    def work_direct(array, options)
+      results = []
+      array.each_with_index do |e,i|
+        results << (options[:with_index] ? yield(e,i) : yield(e))
+      end
+      results
+    end
 
-    kill_on_ctrl_c(pids)
+    def hwprefs_available?
+      `which hwprefs` != ''
+    end
 
-    in_threads(options[:count]) do |i|
-      x = i
-      worker = worker(items, options, &blk)
-      pids[i] = worker[:pid]
+    def work_in_threads(items, options, &block)
+      results = []
+      current = -1
+      exception = nil
 
-      begin
+      in_threads(options[:count]) do
+        # as long as there are more items, work on one of them
         loop do
           break if exception
-          index = Thread.exclusive{ current_index += 1 }
-          break if index >= items.size
 
-          write_to_pipe(worker[:write], index)
-          output = decode(worker[:read].gets.chomp)
+          index = Thread.exclusive{ current+=1 }
+          break if index >= items.size
 
-          if ExceptionWrapper === output
-            exception = output.exception
-          else
-            results[index] = output
+          with_instrumentation items[index], index, options do
+            begin
+              results[index] = call_with_index(items, index, options, &block)
+            rescue Exception => e
+              exception = e
+              break
+            end
           end
         end
-      ensure
-        worker[:read].close
-        worker[:write].close
+      end
+
+      handle_exception(exception, results)
+    end
 
-        # if it goes zombie, rather wait here to be able to debug
-        wait_for_process worker[:pid]
+    def work_in_processes(items, options, &blk)
+      workers = create_workers(items, options, &blk)
+      current_index = -1
+      results = []
+      exception = nil
+      kill_on_ctrl_c(workers.map(&:pid)) do
+        in_threads(options[:count]) do |i|
+          worker = workers[i]
+
+          begin
+            loop do
+              break if exception
+              index = Thread.exclusive{ current_index += 1 }
+              break if index >= items.size
+
+              output = with_instrumentation items[index], index, options do
+                worker.work(index)
+              end
+
+              if ExceptionWrapper === output
+                exception = output.exception
+              else
+                results[index] = output
+              end
+            end
+          ensure
+            worker.close_pipes
+            worker.wait # if it goes zombie, rather wait here to be able to debug
+          end
+        end
       end
+
+      handle_exception(exception, results)
     end
 
-    raise exception if exception
+    def create_workers(items, options, &block)
+      workers = []
+      Array.new(options[:count]).each do
+        workers << worker(items, options.merge(:started_workers => workers), &block)
+      end
+      workers
+    end
 
-    results
-  end
+    def worker(items, options, &block)
+      # use less memory on REE
+      GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
 
-  def self.worker(items, options, &block)
-    # use less memory on REE
-    GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
+      child_read, parent_write = IO.pipe
+      parent_read, child_write = IO.pipe
 
-    child_read, parent_write = IO.pipe
-    parent_read, child_write = IO.pipe
+      pid = Process.fork do
+        begin
+          options.delete(:started_workers).each(&:close_pipes)
 
-    pid = Process.fork do
-      begin
-        parent_write.close
-        parent_read.close
+          parent_write.close
+          parent_read.close
 
-        process_incoming_jobs(child_read, child_write, items, options, &block)
-      ensure
-        child_read.close
-        child_write.close
+          process_incoming_jobs(child_read, child_write, items, options, &block)
+        ensure
+          child_read.close
+          child_write.close
+        end
       end
-    end
 
-    child_read.close
-    child_write.close
+      child_read.close
+      child_write.close
 
-    {:read => parent_read, :write => parent_write, :pid => pid}
-  end
+      Worker.new(parent_read, parent_write, pid)
+    end
 
-  def self.process_incoming_jobs(read, write, items, options, &block)
-    while input = read.gets and input != "\n"
-      index = decode(input.chomp)
-      begin
-        result = call_with_index(items, index, options, &block)
-        result = nil if options[:preserve_results] == false
-      rescue Exception => e
-        result = ExceptionWrapper.new(e)
+    def process_incoming_jobs(read, write, items, options, &block)
+      while !read.eof?
+        index = Marshal.load(read)
+        begin
+          result = call_with_index(items, index, options, &block)
+          result = nil if options[:preserve_results] == false
+        rescue Exception => e
+          result = ExceptionWrapper.new(e)
+        end
+        Marshal.dump(result, write)
       end
-      write_to_pipe(write, result)
     end
-  end
-
-  def self.write_to_pipe(pipe, item)
-    pipe.write(encode(item))
-  end
 
-  def self.wait_for_threads(threads)
-    threads.compact.each do |t|
-      begin
-        t.join
-      rescue Interrupt
-        # thread died, do not stop other threads
+    def wait_for_threads(threads)
+      threads.compact.each do |t|
+        begin
+          t.join
+        rescue Interrupt
+          # thread died, do not stop other threads
+        end
       end
     end
-  end
 
-  def self.wait_for_process(pid)
-    begin
-      Process.wait(pid)
-    rescue Interrupt
-      # process died
+    def handle_exception(exception, results)
+      return nil if exception.class == Break
+      raise exception if exception
+      results
     end
-  end
 
-  def self.encode(obj)
-    Base64.encode64(Marshal.dump(obj)).split("\n").join + "\n"
-  end
-
-  def self.decode(str)
-    Marshal.load(Base64.decode64(str))
-  end
+    # options is either a Integer or a Hash with :count
+    def extract_count_from_options(options)
+      if options.is_a?(Hash)
+        count = options[:count]
+      else
+        count = options
+        options = {}
+      end
+      [count, options]
+    end
 
-  # options is either a Integer or a Hash with :count
-  def self.extract_count_from_options(options)
-    if options.is_a?(Hash)
-      count = options[:count]
-    else
-      count = options
-      options = {}
+    # kill all these pids or threads if user presses Ctrl+c
+    def kill_on_ctrl_c(things)
+      if @to_be_killed
+        @to_be_killed << things
+      else
+        @to_be_killed = [things]
+        Signal.trap :SIGINT do
+          if @to_be_killed.any?
+            $stderr.puts 'Parallel execution interrupted, exiting ...'
+            @to_be_killed.flatten.compact.each { |thing| kill_that_thing!(thing) }
+          end
+          exit 1 # Quit with 'failed' signal
+        end
+      end
+      yield
+    ensure
+      @to_be_killed.pop # free threads for GC and do not kill pids that could be used for new processes
     end
-    [count, options]
-  end
 
-  # kill all these processes (children) if user presses Ctrl+c
-  def self.kill_on_ctrl_c(pids)
-    Signal.trap :SIGINT do
-      $stderr.puts 'Parallel execution interrupted, exiting ...'
-      pids.each { |pid| Process.kill(:KILL, pid) if pid }
-      exit 1 # Quit with 'failed' signal
+    def kill_that_thing!(thing)
+      if thing.is_a?(Thread)
+        thing.kill
+      else
+        begin
+          Process.kill(:KILL, thing)
+        rescue Errno::ESRCH
+          # some linux systems already automatically killed the children at this point
+          # so we just ignore them not being there
+        end
+      end
     end
-  end
 
-  def self.call_with_index(array, index, options, &block)
-    args = [array[index]]
-    args << index if options[:with_index]
-    block.call(*args)
-  end
+    def call_with_index(array, index, options, &block)
+      args = [array[index]]
+      args << index if options[:with_index]
+      block.call(*args)
+    end
 
-  class ExceptionWrapper
-    attr_reader :exception
-    def initialize(exception)
-      @exception = exception
+    def with_instrumentation(item, index, options)
+      on_start = options[:start]
+      on_finish = options[:finish]
+      on_start.call(item, index) if on_start
+      yield
+    ensure
+      on_finish.call(item, index) if on_finish
     end
   end
 end

data/lib/rubygems/dependent/version.rb

@@ -1,5 +1,5 @@
 module Gem
   class Dependent
-    VERSION = Version = '0.2.4'
+    VERSION = Version = '0.2.5'
   end
 end

metadata

@@ -1,42 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: gem-dependent
 version: !ruby/object:Gem::Version
-  version: 0.2.4
-  prerelease: 
+  version: 0.2.5
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain:
-- !binary |-
-  LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURNakNDQWhxZ0F3SUJB
-  Z0lCQURBTkJna3Foa2lHOXcwQkFRVUZBREEvTVJBd0RnWURWUVFEREFkdGFX
-  Tm8KWVdWc01SY3dGUVlLQ1pJbWlaUHlMR1FCR1JZSFozSnZjM05sY2pFU01C
-  QUdDZ21TSm9tVDhpeGtBUmtXQW1sMApNQjRYRFRFek1ESXdNekU0TVRNeE1W
-  b1hEVEUwTURJd016RTRNVE14TVZvd1B6RVFNQTRHQTFVRUF3d0hiV2xqCmFH
-  RmxiREVYTUJVR0NnbVNKb21UOGl4a0FSa1dCMmR5YjNOelpYSXhFakFRQmdv
-  SmtpYUprL0lzWkFFWkZnSnAKZERDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFB
-  RGdnRVBBRENDQVFvQ2dnRUJBTW9yWG8vaGdiVXE5NytrSUk5SApNc1FjTGRD
-  Lzd3UTFaUDJPc2hWSFBrZVAwcUg4TUJIR2c2ZVlpc09YMnViTmFnRjlZVENa
-  V25ocmRLcndwTE9PCmNQTGFaYmpVamxqSjNjUVIzQjhZbjF2ZVY1SWhHODZR
-  c2VUQmp5bXpKV3NMcHFKMVVaR3BmQjl0WGNzRnR1eE8KNnZIdmNJSGR6dmMv
-  T1VrSUN0dExiSCsxcWI2cnNIVWNlcWgrSnJINEdyc0o1SDRoQWZJZHlTMlhN
-  SzdZUktiaApoK0lCdTZkRldKSkJ5ekZzWW1WMVBEWGxuM1VCbWdBdDY1Y21D
-  dTRxUGZUaGlvQ0dEemJTSnJHREdMbXcvcEZYCkZQcFZDbTF6Z1lTYjF2NlFu
-  ZjNjZ1hhMmYyd1lHbTE3K3pBVnlJRHB3cnlGcnU5eUYvakp4RTM4ei9EUnNk
-  OVIKLzg4Q0F3RUFBYU01TURjd0NRWURWUjBUQkFJd0FEQWRCZ05WSFE0RUZn
-  UVVzaU5uWEh0S2VNWVljcjR5SlZtUQpXT05MK0l3d0N3WURWUjBQQkFRREFn
-  U3dNQTBHQ1NxR1NJYjNEUUVCQlFVQUE0SUJBUUFseU43a0tvL05RQ1EwCkFP
-  elpMWjNXQWVQdlN0a0NGSUo1M3RzdjVLeW80cE1BbGx2K0JnUHp6QnQ3cWk2
-  MDVtRlNMNnpCZDl1TG91K1cKQ28zczQ4cDFkeTdDampBZlZRZG1WTkhGM013
-  WHRmQzJPRXl2U1FQaTR4S1I4aWJhOHdhM3hwOUxWbzFQdUxwdwovNkRzckNo
-  V3c3NEhmc0pONnFKT0s2ODRoSmVUOGxCWUFVZmlDM3dEMG93b1BTZytYdHlB
-  QWRkaXNSK0tWNVkxCk5tVkh1THRRY05UWnkrZ1JodDNhaEpSTXVDNlF5TG1r
-  VHNmKzZNYWVud0FNa0FnSGRzd0dzSnp0T25ObkJhM0YKeTBrQ1NXbUs2RCt4
-  L1NiZlM2cjdLZTA3TVJxemlKZEI5R3VFMSswY0lSdUZoOEVRK0xONkhYQ0tN
-  NXBvbi9HVQp5Y3dNWGZsMAotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-date: 2013-09-07 00:00:00.000000000 Z
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDMjCCAhqgAwIBAgIBADANBgkqhkiG9w0BAQUFADA/MRAwDgYDVQQDDAdtaWNo
+  YWVsMRcwFQYKCZImiZPyLGQBGRYHZ3Jvc3NlcjESMBAGCgmSJomT8ixkARkWAml0
+  MB4XDTEzMDIwMzE4MTMxMVoXDTE0MDIwMzE4MTMxMVowPzEQMA4GA1UEAwwHbWlj
+  aGFlbDEXMBUGCgmSJomT8ixkARkWB2dyb3NzZXIxEjAQBgoJkiaJk/IsZAEZFgJp
+  dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMorXo/hgbUq97+kII9H
+  MsQcLdC/7wQ1ZP2OshVHPkeP0qH8MBHGg6eYisOX2ubNagF9YTCZWnhrdKrwpLOO
+  cPLaZbjUjljJ3cQR3B8Yn1veV5IhG86QseTBjymzJWsLpqJ1UZGpfB9tXcsFtuxO
+  6vHvcIHdzvc/OUkICttLbH+1qb6rsHUceqh+JrH4GrsJ5H4hAfIdyS2XMK7YRKbh
+  h+IBu6dFWJJByzFsYmV1PDXln3UBmgAt65cmCu4qPfThioCGDzbSJrGDGLmw/pFX
+  FPpVCm1zgYSb1v6Qnf3cgXa2f2wYGm17+zAVyIDpwryFru9yF/jJxE38z/DRsd9R
+  /88CAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUsiNnXHtKeMYYcr4yJVmQ
+  WONL+IwwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQAlyN7kKo/NQCQ0
+  AOzZLZ3WAePvStkCFIJ53tsv5Kyo4pMAllv+BgPzzBt7qi605mFSL6zBd9uLou+W
+  Co3s48p1dy7CjjAfVQdmVNHF3MwXtfC2OEyvSQPi4xKR8iba8wa3xp9LVo1PuLpw
+  /6DsrChWw74HfsJN6qJOK684hJeT8lBYAUfiC3wD0owoPSg+XtyAAddisR+KV5Y1
+  NmVHuLtQcNTZy+gRht3ahJRMuC6QyLmkTsf+6MaenwAMkAgHdswGsJztOnNnBa3F
+  y0kCSWmK6D+x/SbfS6r7Ke07MRqziJdB9GuE1+0cIRuFh8EQ+LN6HXCKM5pon/GU
+  ycwMXfl0
+  -----END CERTIFICATE-----
+date: 2013-10-21 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: michael@grosser.it
@@ -52,32 +45,25 @@ files:
 homepage: https://github.com/grosser/gem-dependent
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2903456129271945094
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2903456129271945094
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: See which gems depend on your gems
 test_files: []

metadata.gz.sig

@@ -1,4 +1 @@
-:ػ�f<
-�p��%@.�N�&HW�`���ӭ���l�&z���1#�v�ۈ�
-!_��'����޳�����U�E����gѾd=�o�$���aȚ���	h�k�B�_�A:�W��I{w�u/W���g���ǣ8�x9ީ��^.؎�/�1�����B0��8a�'�	�sC7
-j�?O_p.�F��Jf
+�r�_h��S��@�%f@�mUK�M�&����|q��t�����