gemfresh 1.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gemfresh.gemspec
+gemspec

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jon Williams, http://jonathannen.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,20 @@
+# Gemfresh
+Scans your bundler Gemfile and lets you know how up-to-date your gems are.
+
+## Installation and Usage
+
+To install, simply grab the gem:
+    gem install gemfresh
+    
+Change a project directory with a Gemfile (e.g. Your Rails v3+ project) and
+type:
+    gemfresh
+
+This will output a list of current, updateable and obsolete gems. For more
+information on what this means, run gemfresh with the --help option:
+    gemfresh --help
+    
+## License
+MIT Licensed. See MIT-LICENSE.txt for more information.
+
+Thanks [@jonathannen](http://twitter.com/jonathannen).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/gemfresh

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'gemfresh'

data/gemfresh.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = 'gemfresh'
+  s.version     = '1.0.1'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Jon Williams']
+  s.email       = ['jon@jonathannen.com']
+  s.homepage    = 'https://github.com/jonathannen/gemfresh'
+  s.summary     = 'Checks the freshness of your Gemfile.'
+  s.description = 'Scans Gemfiles to check for obsolete and updateable gems.'
+
+  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 = ['.']
+
+  s.add_runtime_dependency 'bundler', '~> 1.0.18'
+end

data/gemfresh.rb

@@ -0,0 +1,234 @@
+require 'net/http'
+require 'rubygems'
+require 'bundler'
+require 'time'
+require File.dirname(__FILE__) + '/support'
+
+# Handle ARGV
+if ARGV.include?('--help') 
+  puts <<-HELP
+  Usage:
+    gemfresh [GEMFILE] [LOCKFILE]
+    
+  Both GEMFILE and LOCKFILE will default to "Gemfile" and "Gemfile.lock" in 
+  your current directory. Generally you'll simply invoke gemfresh from your 
+  Rails (or similar) project directory.
+    
+  Gemfresh will list three categories of gems. "Current" gems are up-to-date.
+  "Obsolete" gems 
+  
+  "Updateable" gems that have a 'fuzzy' gemspec - e.g. '~> 2.2.0' is a fuzzy
+  match for 2.2.1, 2.2.2, etc. Running bundle update will attempt to update
+  your gems. If something is listed at updateable, you have an older version
+  - e.g. "2.2.1", when the current is "2.2.2".
+
+  Just because a gem is updateable or obsolete, doesn't mean it can be 
+  updated. There might be dependencies that limit you to specific versions.
+
+  Check the bundler documentation (http://gembundler.com/) for more 
+  information on Gemfiles.
+  HELP
+  exit
+end
+
+# Check for gemfile and lockfiles
+gemfile = ARGV[0] || './Gemfile'
+lockfile = ARGV[1] || './Gemfile.lock'
+unless File.exists?(gemfile)
+  puts "Couldn't find #{gemfile}.\nRun gemfresh with --help if you need more information."
+  exit
+end
+unless File.exists?(lockfile)
+  puts "Couldn't find #{lockfile}.\nRun gemfresh with --help if you need more information."
+  exit
+end
+
+# Front for RubyGems
+class RubyGemReader < Struct.new('RubyGemReader', :uri)
+  def get(path, data={}, content_type='application/x-www-form-urlencoded')
+    request = Net::HTTP::Get.new(path)
+    request.add_field 'Connection', 'keep-alive'
+    request.add_field 'Keep-Alive', '30'
+    request.add_field 'User-Agent', 'github.com/jonathannen/gemfresh'
+    response = connection.request request
+    response.body  
+  end
+  private
+  # A persistent connection
+  def connection(host = Gem.host)
+    return @connection unless @connection.nil?
+    @connection = Net::HTTP.new self.uri.host, self.uri.port
+    @connection.start    
+    @connection
+  end
+end
+
+# Start in earnets
+puts "Checking the freshness of your Gemfile.\n"
+
+# Get the data from bundler
+Bundler.settings[:frozen] = true
+bundle = Bundler::Dsl.evaluate('./Gemfile', './Gemfile.lock', {})
+
+# Set up the top level values
+deps = bundle.dependencies
+specs = bundle.resolve
+sources = {}
+results = { :current => [], :update => [], :obsolete => [] }
+count = 0
+prereleases = 0
+
+# Map dependencies to their specs, then select RubyGem sources
+dep_specs = deps.map { |dep| [dep, specs.find { |spec| spec.name == dep.name }] }
+dep_specs = dep_specs.select { |dep, spec| !spec.nil? && (spec.source.class == Bundler::Source::Rubygems) }
+
+# Do we have any deps?
+if deps.empty?
+  puts "No top-level RubyGem dependencies found in your Gemfile.\nRun gemfresh with --help if you need more information."
+  exit
+end
+
+# Iterate through the deps, checking the spec against the latest version
+print "Hitting up your RubyGems sources: "
+dep_specs.each do |dep, spec|
+  name = dep.name
+  # version = spec.version.to_s
+  
+  # Get a connection to the rubygem repository, reusing if we can
+  remote = spec.source.remotes.first
+  next if remote.nil?
+  reader = sources[remote]
+  reader = sources[remote] = RubyGemReader.new(remote) if reader.nil?
+  
+  # Get the RubyGems data
+  # lookup = RubyGems.get("/api/v1/gems/#{name}.yaml")
+  gemdata = reader.get("/api/v1/gems/#{name}.yaml")
+  gemdata = YAML.load(gemdata)
+
+  # Get the versions list as well
+  versions = reader.get("/api/v1/versions/#{name}.yaml")
+  versions = YAML.load(versions)
+  
+  # Store the result as a diff object
+  diff = SpecDiff.new(dep, spec, gemdata, versions)
+  results[diff.classify] << diff
+  
+  # Stats
+  prereleases +=1 if diff.prerelease?
+  count += 1
+  
+  # Get the dates of the given and current versions
+  # version_date = versions.find { |v| v['number'] == version }
+  # version_date = Time.parse(version_date['built_at']) unless version_date.nil?
+  # current_date = versions.find { |v| v['number'] == current }
+  # current_date = Time.parse(current_date['built_at']) unless current_date.nil?
+  
+  # Exact match or directly updatable? If so, we can move on
+  # prerelease = false
+  # match = case
+  # when (version == current) then :current
+  # when (dep.match?(dep.name, current)) then :update
+  # else nil
+  # end
+  # 
+  # # Not exact or updatable - we need to check if you're on a pre-release version
+  # if match.nil?
+  #   match = :obsolete
+  #   versions = versions.select { |v| v['prerelease']}.map { |v| v['number'] }
+  #   prerelease = versions.include?(version)
+  #   # If it's a prerelease determine what kind
+  #   if prerelease
+  #     prereleases += 1
+  #     current = versions.first # Big assumption
+  #     match = case
+  #     when (version == current) then :current
+  #     when (dep.match?(dep.name, current)) then :update
+  #     else :obsolete
+  #     end
+  #   end
+  # end
+  
+  # Got our result
+  # results[match] << SpecDiff.new(dep, spec, versions)
+  # [dep, spec, current, prerelease, version_date, current_date]  
+  print "."
+  STDOUT.flush
+end
+puts " Done!"
+
+# Let the user about prereleases
+if prereleases > 0
+  puts "\nYou have #{prereleases} prerelease gem#{prereleases == 1 ? '' : 's'}. Prereleases will be marked with a '*'."
+end
+
+# Output Gem Ages
+puts "\nThe following Gems are:"
+ages = results.values.flatten.group_by(&:build_age)
+{:month1 => 'less than a month', :month6 => '6 months or less', :year1 => 'less than a year', :more => 'more than a year'}.each_pair do |key, value|
+  next if ages[key].nil?
+  puts "-- #{value} old:"
+  puts ages[key].map(&:to_s).join(', ')
+end
+
+# Output Current Gems
+if results[:current].empty?
+  puts "\nYou don't have any current gems."
+else
+  puts "\nThe following gems at the most current version: "
+  puts results[:current].map(&:to_s).join(', ')
+end
+
+# Output Updatable Gems
+if results[:update].empty?
+  puts "\nYou don't have any updatable gems."
+else
+  puts "\nThe following gems are locked to older versions, but your Gemfile allows for the current version: "
+  results[:update].each do |diff| 
+    puts "    #{diff}, with #{diff.dep.requirement} could allow #{diff.version_available}"
+  end
+  puts "Barring dependency issues, these gems could be updated to current using 'bundle update'."
+end
+
+# Output Obsolete Gems
+if results[:obsolete].empty?
+  puts "\nYou don't have any obsolete gems."
+else
+  puts "\nThe following gems are obsolete: "
+  results[:obsolete].each do |diff|
+    released = diff.version_build_date(diff.version_available)
+    released = released.nil? ? '.' : ", #{released.strftime('%d %b %Y')}."
+
+    suggest = diff.suggest
+    suggest = suggest.nil? ? '' : "Also consider version #{suggest}."
+    
+    puts "    #{diff} is now at #{diff.version_available}#{released} #{suggest}"    
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/support.rb

@@ -0,0 +1,84 @@
+class SpecDiff < Struct.new(:dep, :spec, :gemdata, :versions)
+  
+  # Configure the diff
+  def initialize(*args)
+    super
+    # Check for prerelease - Gem rules are that a letter indicates a prerelease
+    # See http://rubygems.rubyforge.org/rubygems-update/Gem/Version.html#method-i-prerelease-3F
+    @prerelease = version_in_use =~ /[a-zA-Z]/
+  end
+  
+  # Return a :month1, :month6, :year1, :more depending on the
+  # build age of the available version
+  def build_age
+    build_date = version_build_date(version_in_use)
+    return :more if build_date.nil?
+    days = ((Time.now.utc - build_date)/(24 * 60 * 60)).round
+    case
+    when days < 31  then :month1
+    when days < 182 then :month6
+    when days < 366 then :year1
+    else :more
+    end
+  end
+
+  # Classify this as :current, :update or :obsolete
+  def classify
+    case
+    when (version_available == version_in_use) then :current
+    when (dep.match?(name, version_available)) then :update
+    else :obsolete
+    end
+  end
+  
+  def prerelease?; @prerelease; end
+  
+  def name; dep.name; end
+  
+  # Is there a suggested version - e.g. if you're using rails 3.0.8, the most
+  # current might be 3.1.0. However, the suggested version would be 3.0.10 --
+  # this will suggest the best version within your current minor version tree.
+  # May return nil if you're at the current suggestion, or if there is no
+  # reasonable match
+  def suggest
+    match = nil
+    head = version_in_use.rpartition('.').first
+    versions.sort_by { |v| v['built_at'] }.reverse.each do |ver|
+      ver = ver['number']
+      match = ver and break if ver.start_with?(head)
+    end
+    (match == version_in_use) || (match == version_available) ? nil : match
+  end
+  
+  # String representation is the basic spec form 'gename (version)', 
+  # with a start appended for prereleases.
+  def to_s
+    "#{spec}#{prerelease? ? '*' : ''}"
+  end
+  
+  # Return the version data for a given string
+  def version_data(version)
+    return nil if versions.nil? || versions.empty?
+    version = versions.find { |v| v['number'] == version }
+  end
+  
+  # Return the build date for a given version string (e.g. '1.2.1')
+  def version_build_date(version)
+    return nil if versions.nil? || versions.empty?
+    version_date = version_data(version)['built_at']
+    version_date.nil? ? nil : Time.parse(version_date)
+  end
+  
+  # Best version available according to RubyGems data
+  def version_available
+    return gemdata["version"].to_s unless prerelease?
+    
+    # Depends if it's a prerelease or not
+    prereleases = versions.select { |v| v['prerelease']}.map { |v| v['number'] }
+    prereleases.first # Big Assumption, but appears correct on data so far
+  end
+  
+  # The version currently in use according to the lockfile
+  def version_in_use; spec.version.to_s; end
+  
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: gemfresh
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- Jon Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-29 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 51
+        segments: 
+        - 1
+        - 0
+        - 18
+        version: 1.0.18
+  type: :runtime
+  version_requirements: *id001
+description: Scans Gemfiles to check for obsolete and updateable gems.
+email: 
+- jon@jonathannen.com
+executables: 
+- gemfresh
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE.txt
+- README.md
+- Rakefile
+- bin/gemfresh
+- gemfresh.gemspec
+- gemfresh.rb
+- support.rb
+has_rdoc: true
+homepage: https://github.com/jonathannen/gemfresh
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Checks the freshness of your Gemfile.
+test_files: []
+