stickler 2.3.0 → 2.4.0

data/examples/as_middleware.ru

@@ -0,0 +1,14 @@
+#-----------------------------------------------------------------------
+#-*- vim: set ft=ruby: -*-
+#
+# Example rackup file for using stickler as middleware in a larger application
+#-----------------------------------------------------------------------
+$:.unshift File.expand_path( File.join( File.dirname(__FILE__), "..", "lib" ) )
+
+require 'stickler'
+
+root = File.expand_path( File.join( File.dirname( __FILE__ ), *%w[ .. test data ]))
+
+puts root
+use ::Stickler::Middleware::Server, :stickler_root => root
+run ::Sinatra::Base

data/examples/auth_repo.ru

@@ -7,7 +7,7 @@ $:.unshift File.expand_path( File.join( File.dirname(__FILE__), "..", "lib" ) )
 
 require 'stickler'
 
-tmp = File.expand_path( File.join( File.dirname( __FILE__ ), "..", "spec", "data" ) )
+tmp = File.expand_path( File.join( File.dirname( __FILE__ ), "..", "test", "tmp" ) )
 
 use Rack::Auth::Basic, 'Secure Stickler' do |u,p|
   (u == "stickler") and (p == "secret")

data/examples/gemcutter_repo.ru

@@ -12,7 +12,7 @@ $:.unshift File.expand_path( File.join( File.dirname(__FILE__), "..", "lib" ) )
 
 require 'stickler'
 
-gem_dir = File.expand_path( "../spec/tmp", File.dirname( __FILE__ ) )
+gem_dir = File.expand_path( "../test/tmp", File.dirname( __FILE__ ) )
 
 use ::Stickler::Middleware::Compression
 use ::Stickler::Middleware::Gemcutter, :repo_root => gem_dir

data/examples/local_repo.ru

@@ -9,7 +9,7 @@ $:.unshift File.expand_path( File.join( File.dirname(__FILE__), "..", "lib" ) )
 require 'stickler/middleware/compression'
 require 'stickler/middleware/local'
 
-gem_dir = File.expand_path( File.join( File.dirname( __FILE__ ), *%w[ .. spec data ]))
+gem_dir = File.expand_path( File.join( File.dirname( __FILE__ ), *%w[ .. test data ]))
 
 puts gem_dir
 use ::Stickler::Middleware::Compression

data/lib/stickler.rb

@@ -1,6 +1,6 @@
 module Stickler
   # The Current Version of the library
-  VERSION = "2.3.0"
+  VERSION = "2.4.0"
 end
 require 'sinatra/base'
 
@@ -8,6 +8,8 @@ require 'stickler/logable'
 require 'stickler/error'
 require 'stickler/paths'
 require 'stickler/spec_lite'
+require 'stickler/gem_container'
+require 'stickler/gemfile_lock_parser'
 
 require 'stickler/repository'
 require 'stickler/middleware'

data/lib/stickler/client.rb

@@ -30,7 +30,7 @@ module Stickler
     def parse( argv )
       opts = Trollop::with_standard_exception_handling( parser ) do
         o = parser.parse( argv )
-        yield parser if block_given?
+        yield( parser, o ) if block_given?
         return o
       end
       return opts
@@ -49,3 +49,4 @@ require 'stickler/client/mirror'
 require 'stickler/client/push'
 require 'stickler/client/unyank'
 require 'stickler/client/yank'
+require 'stickler/client/latest-version'

data/lib/stickler/client/delete.rb

@@ -22,7 +22,7 @@ _
 
       def parse( argv )
         gem_name = nil
-        opts = super( argv ) do |p|
+        opts = super( argv ) do |p,o|
           raise Trollop::CommandlineError, "At least one gem is required to delete" if p.leftovers.empty?
           gem_name = p.leftovers.shift
         end

data/lib/stickler/client/latest-version.rb

@@ -0,0 +1,40 @@
+module Stickler
+  class Client
+    class LatestVersion < Stickler::Client
+      def self.banner
+        <<-_
+Prints the latest version of a gem
+
+Usage: stickler latest-version gem-name
+
+  Options:
+_
+      end
+
+      def parse( argv )
+        gem_name = nil
+        opts = super( argv ) do |p,o|
+          raise Trollop::CommandlineError, "At lest one gem-name is required" if p.leftovers.empty?
+          gem_name = p.leftovers.shift
+        end
+        opts[:gem_name] = gem_name
+        return opts
+      end
+
+      def run
+        opts  = parse( self.argv )
+        repo  = remote_repo_for( opts )
+        match = repo.latest_specs_list.find do |name, version, platform|
+          name == opts[:gem_name]
+        end
+        if match then
+          $stdout.puts match[1]
+        else
+          $stdout.puts "Gem #{opts[:gem_name]} not found in remote repository"
+        end
+      rescue Stickler::Repository::Error => e
+        $stdout.puts "ERROR: #{e.message}"
+      end
+    end
+  end
+end

data/lib/stickler/client/mirror.rb

@@ -5,9 +5,11 @@ module Stickler
       def self.banner
 <<-_
 Pull a specific version of a gem from an upstream gem server
-and store it in a stickler server.
+and store it in a stickler server. Either a specific version
+must be specificied, or a Gemfile.lock must be used.
 
 Usage: stickler mirror [options] --gem-version x.y.z gem
+       stickler mirror [options] Gemfile.lock
 
   Options:
 _
@@ -17,19 +19,26 @@ _
         unless @parser then
           @parser = super
           @parser.opt( :upstream, "The upstream gem server from which to pull", :type => :string, :default => Client.config.upstream )
-          @parser.opt( :gem_version,  "The version of the gem to yank (required)",  :type => :string, :required => true )
-          @parser.opt( :platform, "The platform of the gem to yank", :type => :string, :default => ::Gem::Platform::RUBY )
+          @parser.opt( :gem_version,  "The version of the gem to mirror", :type => :string)
+          @parser.opt( :platform, "The platform of the gem to mirror", :type => :string, :default => ::Gem::Platform::RUBY )
         end
         return @parser
       end
 
       def parse( argv )
-        gem_name = nil
-        opts = super( argv ) do |p|
-          raise Trollop::CommandlineError, "At least one gem is required to mirror" if p.leftovers.empty?
-          gem_name = p.leftovers.shift
+        gem_name     = nil
+        gemfile_lock = nil
+        opts = super( argv ) do |p, o|
+          raise Trollop::CommandlineError, "A Gemfile.lock or a gem name is required to mirror" if p.leftovers.empty?
+          if o[:gem_version] then
+            gem_name = p.leftovers.shift
+          else
+            gemfile_lock = p.leftovers.shift
+            raise Trollop::CommandlineError, "#{lock} must be readable" unless File.readable?( gemfile_lock )
+          end
         end
-        opts[:gem_name] = gem_name
+        opts[:gem_name]     = gem_name
+        opts[:gemfile_lock] = gemfile_lock
         return opts
       end
 
@@ -41,24 +50,47 @@ _
         Stickler::Repository::RemoteMirror.new( opts[:server], :debug => opts[:debug] )
       end
 
-      def run
-        opts = parse( self.argv )
-        repo = remote_repo_for( opts )
-        spec = Stickler::SpecLite.new( opts[:gem_name], opts[:gem_version], opts[:platform] )
-        upstream_host = Addressable::URI.parse( opts[:upstream] ).host
+      def spec_list( opts )
+        if opts[:gem_name] then
+          return [Stickler::SpecLite.new( opts[:gem_name], opts[:gem_version], opts[:platform] )]
+        end
+
+        if opts[:gemfile_lock] then
+          parser = Stickler::GemfileLockParser.new( opts[:gemfile_lock] )
+          return parser.gem_dependencies
+        end
+        raise Sticker::Error, "No gem name, or gemfile lock... no idea what to do"
+      end
 
+      def mirror_one_spec( repo, spec, upstream_host )
         $stdout.write "Asking #{repo.uri} to mirror #{spec.full_name} from #{upstream_host} : "
         $stdout.flush
 
         resp = repo.mirror( spec, upstream_host )
-
         $stdout.puts "OK -> #{repo.uri.join(resp.headers['Location'])}"
+
+      rescue Stickler::Repository::Error => e
+        $stdout.puts "ERROR: #{e.message}"
+      rescue StandardError => e
+        $stdout.puts e.backtrace.join("\n")
+        $stdout.puts "ERROR -> #{e.message}"
+      end
+
+      def run
+        opts          = parse( self.argv )
+        repo          = remote_repo_for( opts )
+        specs         = spec_list( opts )
+        upstream_host = Addressable::URI.parse( opts[:upstream] ).host
+
+        specs.each do |spec|
+          mirror_one_spec( repo, spec, upstream_host )
+        end
       rescue Stickler::Repository::Error => e
         $stdout.puts "ERROR: #{e.message}"
       rescue StandardError => e
         puts e.backtrace.join("\n")
         $stdout.puts "ERROR -> #{e.message}"
-     end
+      end
     end
   end
 end

data/lib/stickler/client/push.rb

@@ -14,7 +14,7 @@ _
 
       def parse( argv )
         gemfiles = []
-        opts = super do |p|
+        opts = super do |p,o|
           raise Trollop::CommandlineError, "At least one file is required to push" if p.leftovers.empty?
           p.leftovers.each do |gemfile|
             raise Trollop::CommandlineError, "#{gemfile} must be readable" unless File.readable?( gemfile )

data/lib/stickler/client/unyank.rb

@@ -22,7 +22,7 @@ _
 
       def parse( argv )
         gem_name = nil
-        opts = super( argv ) do |p|
+        opts = super( argv ) do |p,o|
           raise Trollop::CommandlineError, "At least one gem is required to unyank" if p.leftovers.empty?
           gem_name = p.leftovers.shift
         end

data/lib/stickler/client/yank.rb

@@ -23,7 +23,7 @@ _
 
       def parse( argv )
         gem_name = nil
-        opts = super( argv ) do |p|
+        opts = super( argv ) do |p,o|
           raise Trollop::CommandlineError, "At least one gem is required to yank" if p.leftovers.empty?
           gem_name = p.leftovers.shift
         end

data/lib/stickler/gem_container.rb

@@ -0,0 +1,40 @@
+module Stickler
+  #
+  # Wrap the class that opens the gem file and gives access to all the gem file
+  # internals. The class that implements this in rubygems itself changed, so we
+  # need to be backwards compatible with folks that are using older versions of
+  # rubygems.
+  #
+  class GemContainer
+    attr_reader :path
+    def initialize( gem_file_path )
+      @path      = gem_file_path
+      @container = load_container( path )
+    end
+
+    def spec
+      @container.spec
+    end
+
+    private
+
+    # Rubygems transitions to using Gem::Package, so if we have that use it,
+    # otherwise fall back to the older method of using Gem::Format
+    begin
+      require 'rubygems/package'
+      def load_container( path )
+        Gem::Package.new( path )
+      end
+    rescue LoadError
+      puts "Unable to load 'rubygems/package' falling back to Gem::Format"
+      begin
+        require 'rubygems/format'
+        def load_container( path )
+          Gem::Format.from_file_by_path( path )
+        end
+      rescue LoadError
+        abort "FAilure to load rubygems/format"
+      end
+    end
+  end
+end

data/lib/stickler/gemfile_lock_parser.rb

@@ -0,0 +1,47 @@
+module Stickler
+  class GemfileLockParser
+    attr_reader :gem_dependencies
+
+
+    def initialize( path )
+      p = Pathname.new( path )
+      raise Stickler::Error, "#{path} does not exist"  unless p.exist?
+      raise Stickler::Error, "#{path} is not readable" unless p.readable?
+      parse( p.read )
+    end
+
+    def depends_on?( name )
+      gem_dependencies.any?{ |spec| spec.name == name }
+    end
+
+    private
+
+    def parse( text )
+      parts             = partition( text )
+      @gem_dependencies = parse_dependencies( parts['GEM'] )
+    end
+
+    def parse_dependencies( lines )
+      drop_until_specs( lines )
+      deps = []
+      lines.each do |line|
+        md = line.match( /\A\s{4}(\S+)\s+\(([\w\.]+)\)\Z/ )
+        next if md.nil?
+        deps << Stickler::SpecLite.new( md.captures[0], md.captures[1] )
+      end
+      return deps
+    end
+
+    def drop_until_specs( lines )
+      lines.drop_while{ |l| %w[ remote specs ].include?( l.strip.split(":").first ) }
+    end
+
+    def partition( text )
+      text.split("\n\n").each_with_object({}) { | p, h |
+        next if p.empty?
+        parts = p.split("\n").map(&:rstrip)
+        h[parts.first] = parts[1..-1]
+      }
+    end
+  end
+end

data/lib/stickler/middleware.rb

@@ -9,3 +9,4 @@ require 'stickler/middleware/index'
 require 'stickler/middleware/local'
 require 'stickler/middleware/mirror'
 require 'stickler/middleware/not_found'
+require 'stickler/middleware/server'

data/lib/stickler/middleware/server.rb

@@ -0,0 +1,37 @@
+require 'pathname'
+module Stickler::Middleware
+  # Server is the entire stickler stack as a single piece of middleware that
+  # may be used by other libraries that would like to include Stickler in their
+  # application.
+  class Server
+    attr_reader :stickler_root
+
+    def initialize( app, opts = {} )
+      @app            = app
+      @stickler_root  = Pathname.new( opts.fetch( :stickler_root ) ).realpath
+      @run            = server_app
+      validate
+    end
+
+    def call( env )
+      @run.call( env )
+    end
+
+    def server_app
+      root = self.stickler_root
+      Rack::Builder.app( @app )do
+        use Stickler::Middleware::Compression
+        use Stickler::Middleware::Gemcutter, :serve_indexes => false, :repo_root => root.join( "gemcutter" )
+        use Stickler::Middleware::Mirror,    :serve_indexes => false, :repo_root => root.join( "mirror" )
+        use Stickler::Middleware::Index,     :serve_indexes => true
+      end
+    end
+
+    private
+
+    def validate
+      raise ::Stickler::Error, "Stickler root directory '#{stickler_root}' must already exist" unless stickler_root.directory?
+      raise ::Stickler::Error, "Stickler root directory '#{stickler_root}' must be writable" unless stickler_root.writable?
+    end
+  end
+end

data/lib/stickler/repository/api.rb

@@ -109,6 +109,22 @@ module Stickler::Repository
       raise NotImplementedError, not_implemented_msg( :yank )
     end
 
+    #
+    # :call-seq:
+    #   repo.unyank( spec ) -> true or nil
+    #
+    # "unyank" in the sense of undoing "yank"
+    #
+    # This means, put the gem matching +spec+ back into the index so that it
+    # will be found during searching.
+    #
+    # If the gem is sucessfully put back into the index then true is returned.
+    # Otherwise nil is returned
+    #
+    def unyank( spec )
+      raise NotImplementedError, not_implemented_msg( :unyank )
+    end
+
     #
     # :call-seq:
     #   repo.get( spec ) -> bytes

data/lib/stickler/repository/index.rb

@@ -11,9 +11,6 @@ module Stickler::Repository
   class Index
     class Error < ::Stickler::Repository::Error; end 
 
-    # The list of specs in the index
-    attr_reader :specs
-
     # The directory the specs live
     attr_reader :spec_dir
 

data/lib/stickler/repository/local.rb

@@ -2,7 +2,6 @@ require 'stickler/repository/index'
 require 'addressable/uri'
 require 'tempfile'
 require 'forwardable'
-require 'rubygems/format'
 
 module Stickler::Repository
   #
@@ -180,13 +179,14 @@ module Stickler::Repository
     #
     def add( io )
       # spooling to a temp file because Gem::Format.from_io() closes the io
-      # stream it is sent.  Why it does this, I do not know.
+      # stream it is sent.  Why it does this, I do not know. This may be
+      # removed once we are no longer using older rubygems
       tempfile = Tempfile.new(  "uploaded-gem.", temp_dir )
       tempfile.write( io.read )
       tempfile.rewind
 
-      format    = Gem::Format.from_file_by_path( tempfile.path )
-      spec      = Stickler::SpecLite.new( format.spec.name, format.spec.version, format.spec.platform )
+      container = Stickler::GemContainer.new( tempfile.path )
+      spec      = Stickler::SpecLite.new( container.spec.name, container.spec.version, container.spec.platform )
       specs     = search_for( spec )
 
       raise Error, "gem #{spec.full_name} already exists" unless specs.empty?
@@ -201,8 +201,6 @@ module Stickler::Repository
     # See Api#push
     #
     def push( path )
-      # is this line needed? Never used.
-      # spec = specification_from_gem_file( path )
       result = nil
       File.open( path ) do |io|
         result = add( io )
@@ -302,8 +300,8 @@ module Stickler::Repository
     end
 
     def specification_from_gem_file( path )
-      format = Gem::Format.from_file_by_path( path )
-      return format.spec
+      container = Stickler::GemContainer.new( path )
+      return container.spec
     end
 
     def speclite_from_specification( spec )