stickler 0.1.1 → 2.0.0a

data/lib/stickler/repository/api.rb

@@ -0,0 +1,167 @@
+require 'stickler/repository'
+require 'stickler/spec_lite'
+
+module Stickler::Repository
+  #
+  # The API that all Stickler Repository classes MUST implement.
+  # This file is here to document the API
+  #
+  module Api
+    #
+    # :call-seq:
+    #   repo.uri -> URI
+    #
+    # Return the URI of the repo
+    #
+    def uri
+      raise NotImplementedError, not_implemented_msg( :uri )
+    end
+
+    #
+    # :call-seq:
+    #   repo.gems_uri -> URI
+    #
+    # Return the URI to the location holding all the +.gem+ files.
+    #
+    #
+    def gems_uri
+      raise NotImplementedError, not_implemented_msg( :gems_uri )
+    end
+
+    #
+    # :call-seq:
+    #   repo.uri_for_gem( spec ) -> URI
+    #
+    # Given a SpecLite like object, return a URI that can be used
+    # to directly access the gem in the repository.
+    #
+    def uri_for_gem( spec )
+      raise NotImplementedError, not_implemented_msg( :uri_for_gem )
+    end
+
+    #
+    # :call-seq:
+    #   repo.search_for( spec ) -> Array
+    #
+    # +match+ MUST be an object that responds to +name+, +version+ and
+    # +platform+.
+    #
+    # The Array that is returned will be +empty?+ if no gems are found that
+    # match +match+.
+    #
+    # When one or matches is found, the Array will contain contain
+    # Stickler::SpecLite instances.
+    #
+    def search_for( spec )
+      raise NotImplementedError, not_implemented_msg( :search_for )
+    end
+
+    #
+    # :call-seq:
+    #   repo.push( path_to_gem_file ) -> Stickler::SpecLite
+    #
+    # Push, in the sense of the gem commandline command <tt>gem push</tt>.
+    # +path_to_gem_file+ must be a file system location to a .gem file
+    # that is then _pushed_ into the repository.
+    #
+    # The SpecLite returned can be used to retrieve the gem
+    # from the repo using the #get() method.  A direct URI to the
+    # gem may be obtained using the #uri_for() method.
+    #
+    # If the gem pushed already exists, then a Stickler::Repository::Error is
+    # raised.
+    #
+    def push( path_to_gem_file )
+      raise NotImplementedError, not_implemented_msg( :push )
+    end
+
+    #
+    # :call-seq:
+    #   repo.delete( spec ) -> true|false
+    #
+    # Remove the gem matching the spec completely from the respository.
+    # Return +true+ if the gem was removed, +false+ otherwise
+    #
+    def delete( spec )
+      raise NotImplementedError, not_implemented_msg( :delete)
+    end
+
+    #
+    # :call-seq:
+    #   repo.yank( spec ) -> Stickler::SpecLite
+    #
+    # "yank" in the sense of
+    # http://update.gemcutter.org/2010/03/05/february-changelog.html.
+    # This means, remove the gem matching +spec+ from the index, so it will not
+    # be found when searching, but do not remove the gem physically from the
+    # server.  It can still be downloaded directly.
+    #
+    # The SpecLite instance that is returned will have the information that may
+    # be used in the #get() or #uri_for_gem() methods to retrieve the actual
+    # gemfile.
+    #
+    # After a gem has been 'yanked' it MUST not longer be found via the
+    # #search_for() method, nor can it's specification be retrieved via the
+    # #uri_for_specification() method.
+    #
+    # If the gem described by spec does not exist, nil is returned.
+    #
+    def yank( spec )
+      raise NotImplementedError, not_implemented_msg( :yank )
+    end
+
+    #
+    # :call-seq:
+    #   repo.get( spec ) -> bytes
+    #
+    # Retrieve the gem matching the spec from the repository.  The bytes
+    # returned MUST be something that would be acceptable to be written
+    # directly to disk as a .gem file.
+    #
+    # If the gem described by spec does not exist, nil is returned.
+    #
+    def get( spec )
+      raise NotImplementedError, not_implemented_msg( :get )
+    end
+
+    #
+    # :call-seq:
+    #   repo.open( spec ) -> reader
+    #   repo.open( spec ) { |reader| block }
+    #
+    # Open the gem in a readonly manner, similar to that of File.open.
+    # the +reader+ object that is returned MUST respond to +read+,
+    # +close+ and +rewind+.   These methods behave like their corresponding
+    # IO#read, IO#close and IO#rewind methods.
+    #
+    # If the gem described by spec does not exist, nil is returned.
+    # If the gem described by spec does not exist, the block is not called.
+    #
+    def open( spec, &block )
+      raise NotImplementedError, not_implemented_msg( :open )
+    end
+
+    # :stopdoc:
+    def self.api_methods
+      %w[
+          delete
+          gems_uri
+          get
+          open
+          push
+          search_for
+          uri
+          uri_for_gem
+          yank
+        ]
+    end
+    # :startdoc:
+
+    private
+    # :stopdoc:
+    def not_implemented_msg( method )
+      "Please implement #{self.class.name}##{method}"
+    end
+    # :startdoc:
+  end
+end

data/lib/stickler/repository/index.rb

@@ -0,0 +1,97 @@
+require 'stickler/spec_lite'
+require 'stickler/repository'
+
+module Stickler::Repository
+  #
+  # A repository index is a container holding all the SpecLite elements
+  # in the repository.  All the gem specs that this index holds are derived
+  # from actual files on the file system.
+  #
+  # It is modelled somewhat like a Gem::SourceIndex.
+  #
+  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
+
+    # 
+
+    def initialize( spec_dir )
+      @specs = []
+      @spec_dir = spec_dir
+      load_specs
+    end
+
+    def specs
+      load_specs if reload_necessary?
+      return @specs
+    end
+
+    def latest_specs
+      latest = {}
+      specs.each do |s|
+        if old_spec = latest[s.name] then
+          if old_spec.version < s.version then
+            latest[s.name] = s
+          end
+        else
+          latest[s.name] = s
+        end
+      end
+      latest.values
+    end
+
+    def load_specs
+      load_specs_in_dir( self.spec_dir )
+    end
+
+    def reload_necessary?
+      return true
+      # return true unless @last_modified_time
+      # current_modified_time = File.stat( self.spec_dir ).mtime
+      # return (current_modified_time > @last_modified_time )
+    end
+
+    def last_modified_time
+      File.stat( self.spec_dir ).mtime
+    end
+
+    def spec_dir=( d )
+      raise Error, "#{d} is not a directory" unless File.directory?( d )
+      @spec_dir = d
+      @last_modified_time = File.stat( d ).mtime
+    end
+
+    def load_specs_in_dir( spec_dir )
+      return nil unless File.directory?( spec_dir )
+      @specs.clear
+      self.spec_dir = spec_dir
+
+      Dir.foreach( spec_dir ) do |entry|
+        next unless entry =~ /\.gemspec\Z/
+        add_spec_from_file( File.join( spec_dir, entry ) )
+      end
+    end
+
+    def add_spec_from_file( path )
+      return nil unless File.exist?( path )
+      code = File.read( path )
+      full_spec = eval( code, binding, path )
+      raise Error, "File #{path} is not Gem::Specification in ruby format" unless full_spec.is_a?( Gem::Specification )
+
+      full_spec.untaint
+      spec = Stickler::SpecLite.new( full_spec.name, full_spec.version, full_spec.platform )
+      @specs << spec
+    end
+
+    def search( find_spec )
+      specs.select do |spec|
+        spec =~ find_spec
+      end
+    end
+  end
+end

data/lib/stickler/repository/local.rb

@@ -0,0 +1,251 @@
+require 'stickler/spec_lite'
+require 'stickler/repository'
+require 'stickler/repository/api'
+require 'stickler/repository/index'
+require 'addressable/uri'
+require 'tempfile'
+
+module Stickler::Repository
+  #
+  # A local repository of gems.  It implements the Repository::Api
+  # and stores all the gems and specifications local to a root directory.
+  #
+  # It currently has two subdirectories:
+  #
+  # gems/           -> holding the .gem files 
+  # specifications/ -> holding the .gemspec files
+  #
+  #
+  class Local
+    class Error < ::Stickler::Repository::Error; end
+
+    # the root directory of the repository
+    attr_reader :root_dir
+
+    # the directory containing the .gem files
+    attr_reader :gems_dir
+   
+    # the directory containing the .gemspec files
+    attr_reader :specifications_dir
+
+    # a temporary directory for odds and ends
+    attr_reader :temp_dir
+
+    # the index of the repository
+    attr_reader :index
+
+    def initialize( root_dir )
+      @root_dir = File.expand_path( root_dir ) + File::SEPARATOR
+      @gems_dir = File.join( @root_dir, 'gems/' )
+      @specifications_dir = File.join( @root_dir, 'specifications/' )
+      @temp_dir = File.join( @root_dir, "tmp/" )
+      @index = ::Stickler::Repository::Index.new( @specifications_dir )
+      setup_dirs
+    end
+
+    #
+    # See Api#uri
+    #
+    def uri
+      @uri ||= Addressable::URI.convert_path( root_dir )
+    end
+
+    # 
+    # See Api#gems_uri
+    #
+    def gems_uri
+      @gems_uri ||= Addressable::URI.convert_path( gems_dir )
+    end
+
+    #
+    # See Api#uri_from_gem
+    #
+    def uri_for_gem( spec )
+      return nil unless gem_file_exist?( spec )
+      return self.gems_uri.join( spec.file_name )
+    end
+
+    #
+    # A list of all the specs in the repo
+    #
+    def specs
+      @index.specs
+    end
+
+    #
+    # A list of just the latests specs in the repo
+    #
+    def latest_specs
+      @index.latest_specs
+    end
+
+    #
+    # The last time this index was modified
+    #
+    def last_modified_time
+      @index.last_modified_time
+    end
+
+    #
+    # See Api#search_for
+    #
+    def search_for( spec )
+      return index.search( spec )
+    end
+
+    #
+    # See Api#delete
+    #
+    def delete( spec )
+      uninstall( spec )
+    end
+
+    # 
+    # See Api#yank
+    #
+    def yank( spec )
+      uninstall_specification( spec ) if specification_file_exist?( spec )
+      return uri_for_gem( spec )
+    end
+
+
+    #
+    # :call-seq:
+    #   repo.add( io ) -> Stickler::SpecLite
+    #
+    # A lower level version of #push.  The item passed in is an IO like object
+    # that contains the binary stream that is a .gem file.  IO must respond to
+    # #read and #rewind.
+    #
+    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.
+      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 )
+      specs     = search_for( spec )
+
+      raise Error, "gem #{spec.full_name} already exists" unless specs.empty?
+
+      tempfile.rewind
+      return install( spec, tempfile )
+    ensure
+      tempfile.close!
+    end
+
+    #
+    # See Api#push
+    #
+    def push( path )
+      spec = specification_from_gem_file( path )
+      result = nil
+      File.open( path ) do |io|
+        result = add( io )
+      end
+      return result
+    end
+
+    #
+    # See Api#get
+    #
+    def get( spec )
+      return IO.read( full_path_to_gem( spec ) ) if gem_file_exist?( spec )
+      return nil
+    end
+
+    #
+    # See Api#open
+    #
+    def open( spec, &block )
+      return nil unless gem_file_exist?( spec )
+      path = full_path_to_gem( spec )
+      f = File.open( path, "rb" )
+      if block_given? then
+        begin
+          yield f
+        ensure
+          f.close
+        end
+      else
+        return f
+      end
+      return nil
+    end
+
+    def full_path_to_gem( spec )
+      File.join( gems_dir, spec.file_name )
+    end
+
+
+    private
+
+    def setup_dirs
+      [ root_dir, specifications_dir, gems_dir, temp_dir ].each do |dir|
+        FileUtils.mkdir_p( dir ) unless File.directory?( dir )
+      end
+    end
+
+    def full_path_to_specification( spec )
+      File.join( specifications_dir, spec.spec_file_name )
+    end
+
+    def install( spec, io )
+      install_gem( spec, io )
+      install_specification( spec )
+    end
+
+    def install_gem( spec, io )
+      File.open( full_path_to_gem( spec ) , "w+" ) do |of|
+        io.each do |str|
+          of.write( str )
+        end
+      end
+    end
+
+    def install_specification( spec )
+      gemspec = specification_from_gem_file( full_path_to_gem( spec ) )
+      File.open( full_path_to_specification( spec ) , "w+" ) do |f|
+        f.write( gemspec.to_ruby )
+      end
+      return speclite_from_specification( gemspec )
+    end
+
+    def uninstall( spec )
+      uninstall_gem( spec )
+      uninstall_specification( spec )
+    end
+
+    def uninstall_gem( spec )
+      remove_file( full_path_to_gem( spec ) )
+    end
+
+    def uninstall_specification( spec )
+      remove_file( full_path_to_specification( spec ) )
+    end
+
+    def remove_file( path )
+      return false unless File.exist?( path )
+      return true  if File.unlink( path ) > 0
+    end
+
+    def gem_file_exist?( spec )
+      File.exist?( full_path_to_gem( spec ) )
+    end
+
+    def specification_file_exist?( spec )
+      File.exist?( full_path_to_specification( spec ) )
+    end
+
+    def specification_from_gem_file( path )
+      format = Gem::Format.from_file_by_path( path )
+      return format.spec
+    end
+
+    def speclite_from_specification( spec )
+      Stickler::SpecLite.new( spec.name, spec.version.to_s, spec.platform )
+    end
+  end
+end

data/lib/stickler/repository/mirror.rb

@@ -0,0 +1,48 @@
+require 'stickler/repository'
+require 'stickler/repository/remote'
+require 'stickler/repository/local'
+require 'forwardable'
+
+module Stickler::Repository
+  #
+  # A Mirror mirrors gems in a Repository::Remote to a Repository::Local
+  # All of the Repository::Api methods are delegated to the Local instance
+  # and a new method #mirror() is added to pull gems from a Remote location 
+  # and store in the Local instance
+  #
+  class Mirror
+    class Error < ::Stickler::Repository::Error ; end
+
+    extend Forwardable
+
+    def initialize( root_dir )
+      @root_dir = root_dir
+      @local_repo = ::Stickler::Repository::Local.new( @root_dir )
+      @remote_repos = {}
+    end
+    def_delegators :@local_repo, :uri, :gems_uri, :uri_for_gem, :search_for, 
+                                 :push, :delete, :get, :open
+
+    #
+    # :call-seq:
+    #   repo.mirror( spec, host = "rubygems.org" ) -> SpecLite
+    #
+    # Mirror the gem described by spec on the +host+.  If no +host+
+    # is given, it is assumed to be http://rubygems.org/.
+    #
+    def mirror( host, spec )
+      specs = @local_repo.search_for( spec )
+      raise Error, "gem #{spec.full_name} already exists" unless specs.empty?
+
+      repo = remote_repo_for( host )
+      repo.open( spec ) do |io|
+        @local_repo.add( io )
+      end
+      return spec 
+    end
+
+    def remote_repo_for( host )
+      @remote_repos[host] ||= ::Stickler::Repository::Remote.new( host )
+    end
+  end
+end

data/lib/stickler/repository/null.rb

@@ -0,0 +1,58 @@
+require 'stickler/repository'
+
+module Stickler::Repository
+  #
+  # A null repository.  It is in most respecs like a Repository::Local that has
+  # nothing in it.
+  #
+  # The response to +root_dir+ is set by default to be the class name, or
+  # whatever is passed to the initializer.
+  #
+  class Null
+    # the root directory of the repository, this is set in the constructor
+    attr_reader :root_dir
+
+    def initialize( root_dir = self.class.name )
+      @root_dir = root_dir
+    end
+
+    def empty_string( junk = "" )
+      ""
+    end
+    alias :uri :empty_string
+    alias :gems_uri :empty_string
+
+    def nilish( junk = nil, &block )
+      nil
+    end
+    alias :push :nilish
+    alias :delete :nilish
+    alias :yank :nilish
+    alias :get :nilish
+    alias :open :nilish
+    alias :uri_for_gem :nilish
+    alias :full_path_to_gem :nilish
+
+    def last_modified_time
+      Time.now
+    end
+
+    def empty_array( junk = nil )
+      []
+    end
+    alias :specs :empty_array
+    alias :latest_specs :empty_array
+    alias :search_for :empty_array
+
+    def
+
+    def specs
+      Array.new
+    end
+
+    def latest_specs
+      Array.new
+    end
+
+  end
+end