geminabox-jgraichen 0.12.2.1

data/lib/geminabox/gem_version.rb

@@ -0,0 +1,40 @@
+module Geminabox
+
+  class GemVersion
+    attr_accessor :name, :number, :platform
+
+    def initialize(name, number, platform)
+      @name = name
+      @number = number
+      @platform = platform
+    end
+
+    def ruby?
+      !!(platform =~ /ruby/i)
+    end
+
+    def version
+      Gem::Version.create(number)
+    end
+
+    def <=>(other)
+      sort = other.name <=> name
+      sort = version <=>  other.version       if sort.zero?
+      sort = (other.ruby? && !ruby?) ? 1 : -1 if sort.zero? && ruby? != other.ruby?
+      sort = other.platform <=> platform      if sort.zero?
+
+      sort
+    end
+
+    def ==(other)
+      return false unless other.class == self.class
+      [name, number, platform] == [other.name, other.number, other.platform]
+    end
+
+    def gemfile_name
+      included_platform = ruby? ? nil : platform
+      [name, number, included_platform].compact.join('-')
+    end
+  end
+
+end

data/lib/geminabox/gem_version_collection.rb

@@ -0,0 +1,65 @@
+module Geminabox
+
+  # This class represents a sorted collection of Geminabox::GemVersion objects.
+  # It it used widely throughout the system for displaying and filtering gems.
+  class GemVersionCollection
+    include Enumerable
+
+    # Array of Geminabox::GemVersion objects, or an array of [name, version,
+    # platform] triples.
+    def initialize(initial_gems=[])
+      @gems = initial_gems.map{|object|
+        coerce_to_gem_version(object)
+      }.sort
+    end
+
+    # FIXME: Terminology makes no sense when the version are not all of the same
+    # name
+    def oldest
+      @gems.first
+    end
+
+    # FIXME: Terminology makes no sense when the version are not all of the same
+    # name
+    def newest
+      @gems.last
+    end
+
+    def size
+      @gems.size
+    end
+
+    def each(&block)
+      @gems.each(&block)
+    end
+
+    # The collection can contain gems of different names, this method groups them
+    # by name, and then sorts the different version of each name by version and
+    # platform.
+    #
+    # yields 'foo_gem', version_collection
+    def by_name(&block)
+      @grouped ||= @gems.group_by(&:name).map{|name, collection|
+        [name, Geminabox::GemVersionCollection.new(collection)]
+      }.sort_by{|name, collection|
+        name.downcase
+      }
+
+      if block_given?
+        @grouped.each(&block)
+      else
+        @grouped
+      end
+    end
+
+  private
+    def coerce_to_gem_version(object)
+      if object.is_a?(Geminabox::GemVersion)
+        object
+      else
+        Geminabox::GemVersion.new(*object)
+      end
+    end
+  end
+  
+end

data/lib/geminabox/hostess.rb

@@ -0,0 +1,46 @@
+require 'sinatra/base'
+
+module Geminabox
+
+  class Hostess < Sinatra::Base
+    def serve
+      send_file(File.expand_path(File.join(Server.data, *request.path_info)), :type => response['Content-Type'])
+    end
+
+    %w[/specs.4.8.gz
+       /latest_specs.4.8.gz
+       /prerelease_specs.4.8.gz
+    ].each do |index|
+      get index do
+        content_type 'application/x-gzip'
+        serve
+      end
+    end
+
+    %w[/quick/Marshal.4.8/*.gemspec.rz
+       /yaml.Z
+       /Marshal.4.8.Z
+    ].each do |deflated_index|
+      get deflated_index do
+        content_type('application/x-deflate')
+        serve
+      end
+    end
+
+    %w[/yaml
+       /Marshal.4.8
+       /specs.4.8
+       /latest_specs.4.8
+       /prerelease_specs.4.8
+    ].each do |old_index|
+      get old_index do
+        serve
+      end
+    end
+
+    get "/gems/*.gem" do
+      serve
+    end
+
+  end
+end

data/lib/geminabox/incoming_gem.rb

@@ -0,0 +1,70 @@
+module Geminabox
+
+  class IncomingGem
+    def initialize(gem_data, root_path = Geminabox.settings.data)
+      unless gem_data.respond_to? :read
+        raise ArgumentError, "Expected an instance of IO"
+      end
+
+      digest = Digest::SHA1.new
+      if RbConfig::CONFIG["MAJOR"].to_i <= 1 and RbConfig::CONFIG["MINOR"].to_i <= 8
+        @tempfile = Tempfile.new("gem")
+      else
+        @tempfile = Tempfile.new("gem", :encoding => 'binary')
+      end
+
+      while data = gem_data.read(1024**2)
+        @tempfile.write data
+        digest << data
+      end
+
+      @tempfile.close
+      @sha1 = digest.hexdigest
+
+      @root_path = root_path
+    end
+
+    def gem_data
+      File.open(@tempfile.path, "rb")
+    end
+
+    def valid?
+      spec && spec.name && spec.version
+    rescue Gem::Package::Error
+      false
+    end
+
+    def spec
+      @spec ||= extract_spec
+    end
+
+    def extract_spec
+      if Gem::Package.respond_to? :open
+        Gem::Package.open(gem_data, "r", nil) do |pkg|
+          return pkg.metadata
+        end
+      else
+        Gem::Package.new(@tempfile.path).spec
+      end
+    end
+
+    def name
+      @name ||= get_name
+    end
+
+    def get_name
+      filename = %W[#{spec.name} #{spec.version}]
+      filename.push(spec.platform) if spec.platform && spec.platform != "ruby"
+      filename.join("-") + ".gem"
+    end
+
+    def dest_filename
+      File.join(@root_path, "gems", name)
+    end
+
+    def hexdigest
+      @sha1
+    end
+  end
+
+end

data/lib/geminabox/indexer.rb

@@ -0,0 +1,46 @@
+
+# This module addresses Geminabox issue
+# https://github.com/cwninja/geminabox/issues/70
+#
+# The underlying problem is rubygems issue
+# https://github.com/rubygems/rubygems/issues/232, fixed by
+# https://github.com/rubygems/rubygems/pull/364
+#
+# This library (and its call) should be deleted once that pull request is resolved.
+
+require 'geminabox'
+require 'rubygems/indexer'
+
+module Geminabox::Indexer
+  def self.germane?
+    gem_version = Gem::Version.new(Gem::VERSION)
+    v1_8        = Gem::Version.new('1.8')
+    v1_8_25     = Gem::Version.new('1.8.25')
+
+    (gem_version >= v1_8) && (gem_version < v1_8_25)
+  end
+
+  def self.updated_gemspecs(indexer)
+    specs_mtime = File.stat(indexer.dest_specs_index).mtime
+    newest_mtime = Time.at 0
+
+    updated_gems = indexer.gem_file_list.select do |gem|
+      gem_mtime = File.stat(gem).mtime
+      newest_mtime = gem_mtime if gem_mtime > newest_mtime
+      gem_mtime >= specs_mtime
+    end
+
+    indexer.map_gems_to_specs updated_gems
+  end
+
+  def self.patch_rubygems_update_index_pre_1_8_25(indexer)
+    if germane?
+      specs = updated_gemspecs(indexer)
+
+      unless specs.empty?
+        Gem::Specification.dirs = []
+        Gem::Specification.add_specs(*specs)
+      end
+    end
+  end
+end

data/lib/geminabox/proxy.rb

@@ -0,0 +1,13 @@
+
+module Geminabox
+  module Proxy
+    def self.proxy_path(file)
+      File.join File.dirname(__FILE__), 'proxy', file
+    end
+
+    autoload :Hostess,      proxy_path('hostess')
+    autoload :FileHandler,  proxy_path('file_handler')
+    autoload :Splicer,      proxy_path('splicer')
+    autoload :Copier,       proxy_path('copier')
+  end
+end

data/lib/geminabox/proxy/copier.rb

@@ -0,0 +1,29 @@
+
+
+module Geminabox
+  module Proxy
+    class Copier < FileHandler
+
+      def self.copy(file_name)
+        copier = new(file_name)
+        copier.get_file
+        copier
+      end
+
+      def get_file
+        return true if proxy_file_exists?
+        return copy_local if local_file_exists?
+        get_remote
+      end
+
+      def copy_local
+        FileUtils.cp local_path, proxy_path
+      end
+
+      def get_remote
+        File.open(proxy_path, 'w'){|f| f.write(remote_content)}
+      end
+
+    end
+  end
+end

data/lib/geminabox/proxy/file_handler.rb

@@ -0,0 +1,93 @@
+require 'httpclient'
+module Geminabox
+  module Proxy
+    class FileHandler
+
+      attr_reader :file_name
+
+      def initialize(file_name)
+        @file_name = file_name
+        ensure_destination_exists
+      end
+      
+      def local_path
+        File.expand_path(file_name, root_path)
+      end
+
+      def root_path
+        Geminabox.data
+      end
+
+      def local_file_exists?
+        file_exists? local_path
+      end
+      
+      def proxy_file_exists?
+        file_exists? proxy_path
+      end
+
+      def proxy_path
+        File.expand_path(file_name, proxy_folder_path)
+      end
+
+      def file_exists?(path)
+        File.exists? path
+      end
+
+      def proxy_folder_path
+        File.join(root_path, proxy_folder_name)
+      end
+
+      def proxy_folder_name
+        'proxy'
+      end
+
+      def remote_content
+        HTTPClient.get_content(remote_url).force_encoding(encoding)
+      end
+
+      def remote_url
+        "http://rubygems.org/#{file_name}"
+      end
+
+      def local_content
+        File.read(local_path).force_encoding(encoding)
+      end
+
+      private
+      def encoding
+        "UTF-8"
+      end
+
+      def ensure_destination_exists
+        create_local_folder unless local_folder_exists?
+        create_proxy_folder unless proxy_folder_exists?
+      end
+
+      def proxy_file_folder
+        File.dirname proxy_path
+      end
+
+      def proxy_folder_exists?
+        Dir.exists?(proxy_file_folder)
+      end
+
+      def create_proxy_folder
+        FileUtils.mkdir_p(proxy_file_folder)
+      end
+
+      def local_file_folder
+        File.dirname local_path
+      end
+
+      def local_folder_exists?
+        Dir.exists?(local_file_folder)
+      end
+
+      def create_local_folder
+        FileUtils.mkdir_p(local_file_folder)
+      end
+
+    end
+  end
+end

data/lib/geminabox/proxy/hostess.rb

@@ -0,0 +1,88 @@
+require 'sinatra/base'
+require 'net/http'
+
+module Geminabox
+  module Proxy
+    class Hostess < Sinatra::Base
+      attr_accessor :file_handler
+      
+      def serve
+        if file_handler
+          send_file file_handler.proxy_path
+        else
+          send_file(File.expand_path(File.join(Server.data, *request.path_info)), :type => response['Content-Type'])
+        end
+      end
+
+      %w[specs.4.8.gz
+         latest_specs.4.8.gz
+         prerelease_specs.4.8.gz
+      ].each do |index|
+        get "/#{index}" do
+          splice_file index
+          content_type 'application/x-gzip'
+          serve
+        end
+      end
+
+      %w[quick/Marshal.4.8/*.gemspec.rz
+         yaml.Z
+         Marshal.4.8.Z
+      ].each do |deflated_index|
+        get "/#{deflated_index}" do
+          copy_file request.path_info[1..-1]
+          content_type('application/x-deflate')
+          serve
+        end
+      end
+
+      %w[yaml
+         Marshal.4.8
+         specs.4.8
+         latest_specs.4.8
+         prerelease_specs.4.8
+      ].each do |old_index|
+        get "/#{old_index}" do
+          splice_file old_index
+          serve
+        end
+      end
+
+      get "/gems/*.gem" do
+        get_from_rubygems_if_not_local
+        serve
+      end
+
+      private
+      def get_from_rubygems_if_not_local
+
+        file = File.expand_path(File.join(Server.data, *request.path_info))
+
+        unless File.exists?(file)
+          net_http_class.start("production.cf.rubygems.org") do |http|
+            path = File.join(*request.path_info)
+            response = http.get(path)
+            GemStore.create(IncomingGem.new(StringIO.new(response.body)))
+          end
+        end
+
+      end
+
+      def net_http_class
+        return ::Net::HTTP if ENV['http_proxy'].empty?
+        proxy_uri = URI.parse(ENV['http_proxy'])
+        ::Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+      end
+
+      def splice_file(file_name)
+        self.file_handler = Splicer.make(file_name)
+      end
+
+      def copy_file(file_name)
+        self.file_handler = Copier.copy(file_name)
+      end
+
+
+    end
+  end
+end