r5_geminabox 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Tom Lea, Jack Foy, and Rob Nichols
+
+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.markdown

@@ -0,0 +1,133 @@
+# Gem in a Box – Really simple rubygem hosting
+[![Build Status](https://secure.travis-ci.org/geminabox/geminabox.png)](http://travis-ci.org/geminabox/geminabox)
+[![Gem Version](https://badge.fury.io/rb/geminabox.png)](http://badge.fury.io/rb/geminabox)
+
+Geminabox lets you host your own gems, and push new gems to it just like with rubygems.org.
+The bundler dependencies API is supported out of the box.
+Authentication is left up to either the web server, or the Rack stack.
+For basic auth, try [Rack::Auth](http://rack.rubyforge.org/doc/Rack/Auth/Basic.html).
+
+![screen shot](http://pics.tomlea.co.uk/bbbba6/geminabox.png)
+
+## System Requirements
+
+    Tested on Mac OS X 10.8.2
+    Ruby 1.9.3-392
+
+    Tests fail on Ruby 2.0.0-p0
+
+## Server Setup
+
+    gem install geminabox
+
+Create a config.ru as follows:
+
+    require "rubygems"
+    require "geminabox"
+
+    Geminabox.data = "/var/geminabox-data" # ... or wherever
+    run Geminabox::Server
+
+Start your gem server with 'rackup' to run WEBrick or hook up the config.ru as you normally would ([passenger][passenger], [thin][thin], [unicorn][unicorn], whatever floats your boat).
+
+## Legacy RubyGems index
+
+RubyGems supports generating indexes for the so called legacy versions (< 1.2), and since it is very rare to use such versions nowadays, it can be disabled, thus improving indexing times for large repositories. If it's safe for your application, you can disable support for these legacy versions by adding the following configuration to your config.ru file:
+
+    Geminabox.build_legacy = false
+
+## RubyGems Proxy
+
+Geminabox can be configured to pull gems, it does not currently have, from rubygems.org. To enable this mode you can either:
+
+Set RUBYGEM_PROXY to true in the environment:
+
+    RUBYGEMS_PROXY=true rackup
+
+Or in config.ru (before the run command), set:
+
+    Geminabox.rubygems_proxy = true
+
+If you want Geminabox to carry on providing gems when rubygems.org is unavailable, add this to config.ru:
+
+    Geminabox.allow_remote_failure = true 
+
+## HTTP adapter
+
+Geminabox uses the HTTPClient gem to manage its connections to remote resources.
+The relationship is managed via Geminabox::HttpClientAdapter.
+
+If you would like to use an alternative HTTP gem, create your own adapter
+and specify it in config.ru:
+
+    Geminabox.http_adapter = YourHttpAdapter.new
+
+It is recommend (but not essential) that your adapter inherits from HttpAdapter.
+The adapter will need to replace HttpAdapter's methods with those specific to
+the alternative HTTP gem. It should also be able to handle HTTP proxy
+settings. 
+
+Defining your own adapter also allows you to configure Geminabox to use the
+local systems SSL certificates.
+
+TemplateFaradayAdapter is provided as an example of an alternative HTTPAdapter.
+
+## Client Usage
+
+Since version 0.10, Geminabox supports the standard gemcutter push API:
+
+    gem push pkg/my-awesome-gem-1.0.gem --host HOST
+
+You can also use the gem plugin:
+
+    gem install geminabox
+
+    gem inabox pkg/my-awesome-gem-1.0.gem
+
+Configure Gem in a box (interactive prompt to specify where to upload to):
+
+    gem inabox -c
+
+Change the host to upload to:
+
+    gem inabox -g HOST
+
+Simples!
+
+## Command Line Help
+
+    Usage: gem inabox GEM [options]
+
+      Options:
+        -c, --configure                  Configure GemInABox
+        -g, --host HOST                  Host to upload to.
+        -o, --overwrite                  Overwrite Gem.
+
+
+      Common Options:
+        -h, --help                       Get help on this command
+        -V, --[no-]verbose               Set the verbose level of output
+        -q, --quiet                      Silence commands
+            --config-file FILE           Use this config file instead of default
+            --backtrace                  Show stack backtrace on errors
+            --debug                      Turn on Ruby debugging
+
+
+      Arguments:
+        GEM       built gem to push up
+
+      Summary:
+        Push a gem up to your GemInABox
+
+      Description:
+        Push a gem up to your GemInABox
+
+## Licence
+
+Fork it, mod it, choose it, use it, make it better. All under the MIT License.
+
+[WTFBPPL]: http://tomlea.co.uk/WTFBPPL.txt
+[sinatra]: http://www.sinatrarb.com/
+[passenger]: http://www.modrails.com/
+[thin]: http://code.macournoyer.com/thin/
+[unicorn]: http://unicorn.bogomips.org/

data/lib/geminabox.rb

@@ -0,0 +1,79 @@
+require 'rubygems'
+require 'digest/md5'
+require 'builder'
+require 'sinatra/base'
+require 'rubygems/user_interaction'
+require 'rubygems/indexer'
+require 'rubygems/package'
+require 'rss/atom'
+require 'tempfile'
+require 'json'
+
+module Geminabox
+
+  require_relative 'geminabox/version'
+  require_relative 'geminabox/proxy'
+  require_relative 'geminabox/http_adapter'
+
+  def self.geminabox_path(file)
+    File.join File.dirname(__FILE__), 'geminabox', file
+  end
+
+  autoload :Hostess,                geminabox_path('hostess')
+  autoload :GemStore,               geminabox_path('gem_store')
+  autoload :GemStoreError,          geminabox_path('gem_store_error')
+  autoload :RubygemsDependency,     geminabox_path('rubygems_dependency')
+  autoload :GemListMerge,           geminabox_path('gem_list_merge')
+  autoload :GemVersion,             geminabox_path('gem_version')
+  autoload :GemVersionCollection,   geminabox_path('gem_version_collection')
+  autoload :Server,                 geminabox_path('server')
+  autoload :DiskCache,              geminabox_path('disk_cache')
+  autoload :IncomingGem,            geminabox_path('incoming_gem')
+
+  class << self
+
+    attr_accessor(
+      :data,
+      :public_folder,
+      :build_legacy,
+      :incremental_updates,
+      :views,
+      :allow_replace,
+      :gem_permissions,
+      :allow_delete,
+      :rubygems_proxy,
+      :http_adapter,
+      :allow_remote_failure
+    )
+
+    def set_defaults(defaults)
+      defaults.each do |method, default|
+        variable = "@#{method}"
+        instance_variable_set(variable, default) unless instance_variable_get(variable)
+      end
+    end
+
+    def settings
+      Server.settings
+    end
+    
+    def call(env)
+      Server.call env
+    end
+  end
+
+  set_defaults(
+    data:                 File.join(File.dirname(__FILE__), *%w[.. data]),
+    public_folder:        File.join(File.dirname(__FILE__), *%w[.. public]),
+    build_legacy:         false,
+    incremental_updates:  true,
+    views:                File.join(File.dirname(__FILE__), *%w[.. views]),
+    allow_replace:        false,
+    gem_permissions:      0644,
+    rubygems_proxy:       (ENV['RUBYGEMS_PROXY'] == 'true'),
+    allow_delete:         true,
+    http_adapter:         HttpClientAdapter.new,
+    allow_remote_failure: false
+  )
+    
+end

data/lib/geminabox/disk_cache.rb

@@ -0,0 +1,73 @@
+require "fileutils"
+module Geminabox
+  class Geminabox::DiskCache
+    attr_reader :root_path
+
+    def initialize(root_path)
+      @root_path = root_path
+      ensure_dir_exists!
+    end
+
+    def flush_key(key)
+      path = path(key_hash(key))
+      FileUtils.rm_f(path)
+    end
+
+    def flush
+      FileUtils.rm_rf(root_path)
+      ensure_dir_exists!
+    end
+
+    def cache(key)
+      key_hash = key_hash(key)
+      read(key_hash) || write(key_hash, yield)
+    end
+
+    def marshal_cache(key)
+      key_hash = key_hash(key)
+      marshal_read(key_hash) || marshal_write(key_hash, yield)
+    end
+
+  protected
+
+    def ensure_dir_exists!
+      FileUtils.mkdir_p(root_path)
+    end
+
+    def key_hash(key)
+      Digest::MD5.hexdigest(key)
+    end
+
+    def path(key_hash)
+      File.join(root_path, key_hash)
+    end
+
+    def read(key_hash)
+      read_int(key_hash) { |path| File.read(path) }
+    end
+
+    def marshal_read(key_hash)
+      read_int(key_hash) { |path| Marshal.load(File.open(path)) }
+    end
+
+    def read_int(key_hash)
+      path = path(key_hash)
+      yield(path) if File.exists?(path)
+    end
+
+    def write(key_hash, value)
+      write_int(key_hash) { |f| f << value }
+      value
+    end
+
+    def marshal_write(key_hash, value)
+      write_int(key_hash) { |f| Marshal.dump(value, f) }
+      value
+    end
+
+    def write_int(key_hash)
+      File.open(path(key_hash), 'wb') { |f| yield(f) }
+    end
+
+  end
+end

data/lib/geminabox/gem_list_merge.rb

@@ -0,0 +1,51 @@
+module Geminabox
+  class GemListMerge
+    attr_accessor :list
+
+    def self.from(*lists)
+      lists.map{|list| new(list)}.inject(:merge)
+    end
+
+    def initialize(list)
+      @list = list
+    end
+
+    def merge(other)
+      combine_hashes(other).values.flatten.sort do |x, y|
+        x.values[ignore_dependencies] <=> y.values[ignore_dependencies]
+      end
+    end
+
+    def hash
+      list.each do |item|
+        ensure_symbols_as_keys(item)
+        name = item[:name].to_sym
+        collection[name] ||= []
+        collection[name] << item unless collection[name].include?(item)
+      end
+      collection
+    end
+
+    def collection
+      @collection ||= {}
+    end
+
+    def combine_hashes(other)
+      hash.merge(other.hash) do |key, value, other_value|
+        (value + other_value).uniq{|v| v.values[ignore_dependencies]}
+      end
+    end
+
+    def ignore_dependencies
+      0..-2
+    end
+
+    def ensure_symbols_as_keys(item)
+      item.keys.each do |key|
+        next if key.kind_of? Symbol
+        item[key.to_sym] = item.delete(key)
+      end
+    end
+
+  end
+end

data/lib/geminabox/gem_store.rb

@@ -0,0 +1,99 @@
+module Geminabox
+
+  class GemStore
+    attr_accessor :gem, :overwrite
+
+    def self.create(gem, overwrite = false)
+      gem_store = new(gem, overwrite)
+      gem_store.save
+    end
+
+    def initialize(gem, overwrite = false)
+      @gem = gem
+      @overwrite = overwrite && overwrite == 'true'
+    end
+
+    def save
+      ensure_gem_valid
+      prepare_data_folders
+      check_replacement_status
+      write_and_index
+    end
+
+    def prepare_data_folders
+      ensure_existing_data_folder_compatible
+      begin
+        FileUtils.mkdir_p(File.join(Geminabox.data, "gems"))
+      rescue
+        raise GemStoreError.new(
+          500,
+          "Could not create #{File.expand_path(Geminabox.data)}."
+        )
+      end
+    end
+
+    def check_replacement_status
+      if !overwrite and Geminabox::Server.disallow_replace? and File.exist?(gem.dest_filename)
+        if existing_file_digest != gem.hexdigest
+          raise GemStoreError.new(409, "Updating an existing gem is not permitted.\nYou should either delete the existing version, or change your version number.")
+        else
+          raise GemStoreError.new(200, "Ignoring upload, you uploaded the same thing previously.\nPlease use -o to ovewrite.")
+        end
+      end
+    end
+
+    def ensure_gem_valid
+      raise GemStoreError.new(400, "Cannot process gem") unless gem.valid?
+    end
+
+    private
+    def ensure_existing_data_folder_compatible
+      if File.exists? Geminabox.data
+        ensure_data_folder_is_directory
+        ensure_data_folder_is_writable
+      end
+    end
+
+    def ensure_data_folder_is_directory
+      raise GemStoreError.new(
+        500,
+        "Please ensure #{File.expand_path(Geminabox.data)} is a directory."
+      ) unless File.directory? Geminabox.data
+    end
+
+    def ensure_data_folder_is_writable
+      raise GemStoreError.new(
+        500,
+        "Please ensure #{File.expand_path(Geminabox.data)} is writable by the geminabox web server."
+      ) unless File.writable? Geminabox.data
+    end
+
+    def existing_file_digest
+      Digest::SHA1.file(gem.dest_filename).hexdigest
+    end
+
+    def write_and_index
+      tmpfile = gem.gem_data
+      atomic_write(gem.dest_filename) do |f|
+        while blk = tmpfile.read(65536)
+          f << blk
+        end
+      end
+      Geminabox::Server.reindex
+    end
+
+    # based on http://as.rubyonrails.org/classes/File.html
+    def atomic_write(file_name)
+      temp_dir = File.join(Geminabox.data, "_temp")
+      FileUtils.mkdir_p(temp_dir)
+      temp_file = Tempfile.new("." + File.basename(file_name), temp_dir)
+      temp_file.binmode
+      yield temp_file
+      temp_file.close
+      File.rename(temp_file.path, file_name)
+      File.chmod(Geminabox::Server.gem_permissions, file_name)
+    end
+
+  end
+
+end