gemstash 1.0.0.pre.1-java → 2.6.0-java

data/README.md

@@ -1,139 +0,0 @@
-[![Build Status](https://travis-ci.org/bundler/gemstash.svg?branch=master)](https://travis-ci.org/bundler/gemstash)
-
-<p align="center"><img src="gemstash.png" /></p>
-
-## What is Gemstash?
-
-Gemstash is both a cache for remote servers such as https://www.rubygems.org,
-and a private gem source.
-
-If you are using [bundler](http://bundler.io/) across many machines that have
-access to a server within your control, you might want to use Gemstash.
-
-If you produce gems that you don't want everyone in the world to have access to,
-you might want to use Gemstash.
-
-If you frequently bundle the same set of gems across multiple projects, you
-might want to use Gemstash.
-
-Are you only using gems from https://www.rubygems.org, and don't bundle the same
-gems frequently? Well, maybe you don't need Gemstash... yet.
-
-## Quickstart Guide
-
-### Setup
-
-Gemstash is designed to be quick and painless to get set up. By the end of this
-Quickstart Guide, you will be able to bundle stashed gems from public sources
-against a Gemstash server running on your machine.
-
-Install Gemstash to get started:
-```
-$ gem install gemstash
-```
-
-After it is installed, starting Gemstash requires no additional steps. Simply
-start the Gemstash server with the `gemstash` command:
-```
-$ gemstash start
-```
-
-You may have noticed that the command finished quickly. This is because Gemstash
-will run the server in the background by default. The server runs on port 9292.
-
-### Bundling
-
-With the server running, you can bundle against it. Create a simple `Gemfile`
-like the following:
-```ruby
-# ./Gemfile
-source "http://localhost:9292"
-gem "rubywarrior"
-```
-
-The first line is important, as it will tell Bundler to use your new Gemstash
-server. The gems you include should be gems you don't yet have installed,
-otherwise Gemstash will have nothing to stash. Now bundle:
-```
-$ bundle install --path .bundle
-```
-
-Your Gemstash server has fetched the gems from https://www.rubygems.org and
-cached them for you! To prove this, you can disable your Internet connection and
-try again. The gem dependencies from https://www.rubygems.org are cached for 30
-minutes, so if you bundle again before that, you can successfully bundle without
-an Internet connection:
-```
-$ # Disable your Internet first!
-$ rm -rf Gemfile.lock .bundle
-$ bundle
-```
-
-### Stopping the Server
-
-Once you've finish using your Gemstash server, you can stop it just as easily as
-you started it:
-```
-$ gemstash stop
-```
-
-### Under the Hood
-
-You might wonder where the gems are stored. After running the commands above,
-you will find a new directory at `~/.gemstash`. This directory holds all the
-cached and private gems. It also has a server log, the database, and
-configuration for Gemstash. If you prefer, you can [point to a different
-directory](docs/config.md#files).
-
-Gemstash uses [SQLite](https://www.sqlite.org/) to store details about private
-gems. The database will be located in `~/.gemstash`, however you won't see the
-database appear until you start using private gems. If you prefer, you can [use
-a different database](docs/config.md#database).
-
-Gemstash temporarily caches things like gem dependencies in memory. Anything
-cached in memory will last for 30 minutes before being retrieved again. You can
-[use memcached](docs/config.md#cache) instead of caching in memory. Gem files
-are always cached permanently, so bundling with a `Gemfile.lock` with all gems
-cached will never call out to https://www.rubygems.org.
-
-The server you ran is provided via [Puma](http://puma.io/) and
-[Rack](http://rack.github.io/), however they are not customizable at this point.
-
-## Deep Dive
-
-For a deep dive into the following subjects, follow the links:
-* [Private gems](docs/private_gems.md)
-* [Multiple gem sources](docs/multiple_sources.md)
-* [Using Gemstash as a mirror](docs/mirror.md)
-* [Customizing the server (database, storage, caching, and more)](docs/config.md)
-* [Deploying Gemstash](docs/deploy.md)
-* [Debugging Gemstash](docs/debug.md)
-
-## Reference
-
-For an anatomy of various configuration and commands, follow the links:
-* [Configuration](docs/reference.md#configuration)
-* [Authorize](docs/reference.md#authorize)
-* [Start](docs/reference.md#start)
-* [Stop](docs/reference.md#stop)
-* [Status](docs/reference.md#status)
-* [Setup](docs/reference.md#setup)
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run
-`rake` to run RuboCop and the tests. While developing, you can run
-`bin/gemstash` to run Gemstash. You can also run `bin/console` for an
-interactive prompt that will allow you to experiment.
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at
-https://github.com/bundler/gemstash. This project is intended to be a safe,
-welcoming space for collaboration, and contributors are expected to adhere to
-the [Contributor Covenant](CODE_OF_CONDUCT.md) code of conduct.
-
-## License
-
-The gem is available as open source under the terms of the
-[MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,35 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-desc "Run specs"
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = %w(--color)
-end
-
-task :spec => :rubocop
-task :default => :spec
-
-desc "Generate Table of Contents for certain docs"
-task :toc do
-  toc_dir = File.expand_path("../tmp/", __FILE__)
-  toc = File.join(toc_dir, "gh-md-toc")
-
-  unless File.exist?(toc)
-    require "open-uri"
-    toc_contents = open("https://raw.githubusercontent.com/ekalinin/github-markdown-toc/master/gh-md-toc", &:read)
-    Dir.mkdir(toc_dir) unless Dir.exist?(toc_dir)
-    File.write(toc, toc_contents)
-    File.chmod(0776, toc)
-  end
-
-  doc = File.expand_path("../docs/reference.md", __FILE__)
-  old_contents = File.read(doc)
-  old_contents.sub!(/\A.*?^---$/m, "---")
-  File.write(doc, old_contents)
-  toc_contents = `"#{toc}" "#{doc}"`
-  toc_contents.sub!(/Created by.*$/, "")
-  File.write(doc, "#{toc_contents}\n#{old_contents}")
-end

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "gemstash"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start

data/bin/gemstash

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-require "bundler/setup"
-exec "exe/gemstash", *ARGV

data/bin/setup

@@ -1,5 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-IFS=$'\n\t'
-
-bundle install

data/docs/config.md

@@ -1,136 +0,0 @@
-# Customizing the Server
-
-Although Gemstash is designed for as minimal setup as possible, there may be
-times you will want to change some of the default configuration. By the end of
-this guide, you will be able to customize some of the Gemstash behavior,
-including where files are stored, what database Gemstash uses, and how Gemstash
-caches certain requests.
-
-## Setup
-
-Several customizable options are available via an interactive Gemstash command.
-Run `gemstash setup` and answer the questions it provides (a blank answer will
-use the default value):
-<pre>
-$ gemstash setup
-Where should files go? [~/.gemstash]
-Cache with what? [MEMORY, memcached] <strong>memcached</strong>
-What is the comma separated Memcached servers? [localhost:11211]
-What database adapter? [SQLITE3, postgres] <strong>postgres</strong>
-Where is the database? [postgres:///gemstash]
-Checking that the cache is available
-Checking that the database is available
-The database is not available
-</pre>
-
-Once you've answered the questsions, some checks will be made to ensure the
-configuration will work. For example, the database didn't exist in the previous
-example, so the command failed and the configuration wasn't saved. If the
-command passes, you may provide the `--redo` option to force configuration to be
-redone:
-<pre>
-$ gemstash setup --redo
-Where should files go? [~/.gemstash]
-Cache with what? [MEMORY, memcached] <strong>memcached</strong>
-What is the comma separated Memcached servers? [localhost:11211]
-What database adapter? [SQLITE3, postgres]
-Checking that the cache is available
-Checking that the database is available
-You are all setup!
-</pre>
-
-Once all checks have passed, Gemstash will store your answers in the
-configuration file located at `~/.gemstash/config.yml`.
-
-## Files
-
-Storage in Gemstash defaults to `~/.gemstash` unless otherwise specified. You
-can change this in your config file via the `:base_path` key:
-```yaml
-# ~/.gemstash/config.yml
----
-:base_path: "/var/gemstash"
-```
-
-When customizing the `base_path`, the directory must exist, otherwise Gemstash
-will fail to run. Thus, if you want to use `/var/gemstash` like in the previous
-example, make sure to `mkdir /var/gemstash` and grant access to the directory
-for the user you run Gemstash with.
-
-## Database
-
-The `:db_adapter` configuration key specifies what database you will be using.
-The default `:db_adapter` is [`sqlite3`](https://www.sqlite.org/), which will
-use a database file located within your `:base_path`. The database file will
-always be named `gemstash.db`.
-
-You may also use [`postgres`](http://www.postgresql.org/) for your
-`:db_adapter`. When using PostgreSQL, you need to specify the `:db_url` to point
-to an existing database. Here is an example configuration to use the `postgres`
-adapter:
-```yaml
-# ~/.gemstash/config.yml
----
-:db_adapter: postgres
-:db_url: postgres:///gemstash
-```
-
-Regardless of the adapter you choose, the database will automatically migrate to
-your version of Gemstash whenever the database is needed. Except for `sqlite3`,
-you only need to ensure the database exists and Gemstash will do the rest.
-
-## Cache
-
-Certain things (like dependencies) are cached in memory. This avoids web calls
-to the gem source, and database calls for private gems. The memory cache can
-optionally be swapped out with a [Memcached](http://memcached.org/) server (or
-cluster of servers). To use Memcached, you must update the `:cache_type`
-configuration key to be `memcached`, and provide the servers via the
-`:memcached_servers` configuration key:
-```yaml
-# ~/.gemstash/config.yml
----
-:cache_type: memcached
-:memcached_servers: memcached1.local:11211,memcached2.local:11211
-```
-
-Note that the `:memcached_servers` requires a comma separated list of servers.
-All caching lasts for 30 minutes.
-
-## Server
-
-Gemstash uses [Puma](http://puma.io/) and [Rack](http://rack.github.io/) as the
-server. Alternate server configurations are not currently supported, but you can
-take a look at the [Puma configuration](../lib/gemstash/puma.rb) and the [rackup
-file](../lib/gemstash/config.ru) for inspiration.
-
-While the server is not customizable, the way Gemstash binds the port can be
-changed. To change the binding, update the `:bind` configuration key:
-```yaml
-# ~/.gemstash/config.yml
----
-:bind: tcp://0.0.0.0:4242
-```
-
-This maps directly to the [Puma bind
-flag](https://github.com/puma/puma#binding-tcp--sockets), and will support
-anything valid for that flag.
-
-## Config File Location
-
-By default, configuration for Gemstash will be at `~/.gemstash/config.yml`. This
-can be changed by providing the `--config-file` option to the various Gemstash
-commands:
-```
-$ gemstash setup --config-file ./gemstash-config.yml
-$ gemstash authorize --config-file ./gemstash-config.yml
-$ gemstash start --config-file ./gemstash-config.yml
-$ gemstash stop --config-file ./gemstash-config.yml
-$ gemstash status --config-file ./gemstash-config.yml
-```
-
-When providing `--config-file` to `gemstash setup`, the provided file will be
-output to with the provided configuration. **This will overwrite** any existing
-configuration. If the file doesn't exist when providing `--config-file` to
-`gemstash start`, `gemstash stop`, `gemstash status`, and `gemstash authorize`,
-the default configuration will be used.

data/docs/debug.md

@@ -1,24 +0,0 @@
-# Debugging Gemstash
-
-If you are finding Gemstash isn't behaving as you would expect, you might want
-to start by looking at the server log. You can find the log at `server.log`
-within your base directory. By default, this will be at
-`~/.gemstash/server.log`.
-
-You might find it easier to view the log directly in your terminal. If you run
-Gemstash [in non-daemonized form](reference.md#--no-daemonize), the log will be
-output directly to standard out:
-```
-$ gemstash start --no-daemonize
-```
-
-You can also [check the status](reference.md#status) of the server:
-```
-$ gemstash status
-```
-
-The server status is checked by passing through to
-[pumactl](https://github.com/puma/puma#pumactl).
-
-If you find a bug, please don't hesitate to [open a bug
-report](../README.md#contributing)!

data/docs/deploy.md

@@ -1,30 +0,0 @@
-# Deploying Gemstash
-
-Bundler is here for the rescue to keep Gemstash up to date! Create a `Gemfile`
-pointing to Gemstash:
-```ruby
-# ./Gemfile
-source "https://www.rubygems.org"
-gem "gemstash"
-```
-
-Then `bundle` to create your `Gemfile.lock`. When you are ready to upgrade,
-simply `bundle update`. You may need to run `gemstash` via `bundle exec`.
-Alternatively, you can `gem uninstall gemstash` and `gem install gemstash` when
-you want to upgrade.
-
-Gemstash will automatically run any necessary migrations, so updating the gem is
-all that needs to be done.
-
-It is probably wise to stop Gemstash before upgrading, then starting again once
-you are done:
-```
-$ bundle exec gemstash stop
-$ bundle update
-$ bundle exec gemstash start
-```
-
-## Downgrading
-
-It is not recommended to go backwards in Gemstash versions. Migrations may have
-run that could leave the database in a bad state.

data/docs/mirror.md

@@ -1,30 +0,0 @@
-# Using Gemstash as a Mirror
-
-If you don't have control over your `Gemfile`, or you don't want to force
-everyone on your team to go through the Gemstash server, you can use Bundler
-mirroring to bundle against your Gemstash server.
-
-For each source in your `Gemfile`, add a mirror pointing to your Gemstash
-server:
-```
-$ bundle config mirror.http://rubygems.org http://localhost:9292
-$ bundle config mirror.https://my.gem-source.local http://localhost:9292/upstream/$(ruby -rcgi -e 'puts CGI.escape("https://my.gem-source.local")')
-```
-
-From now on, bundler will fetch gems from those sources via your Gemstash
-server.
-
-# Simpler Gemstash Mirrors
-
-**WARNING: This feature is not yet available.**
-
-**This feature requires Bundler to be at least version `1.11.0`.**
-
-If you are using Bundler version `1.11.0` or greater, the mirroring becomes a
-bit easier:
-```
-$ bundle config mirror.http://rubygems.org http://localhost:9292
-$ bundle config mirror.https://my.gem-source.local http://localhost:9292
-```
-
-Bundler will then send headers to Gemstash to indicate the correct upstream.

data/docs/multiple_sources.md

@@ -1,68 +0,0 @@
-# Multiple Gem Sources
-
-Gemstash will stash from any amount of gem sources. By the end of this guide,
-you will be able to bundle using multiple gem sources, all stashed within your
-Gemstash server.
-
-## Default Source
-
-When you don't provide an explicit source (as with the [Quickstart
-Guide](../README.md#quickstart-guide)), your gems will be fetched from
-https://www.rubygems.org. This default source is not set in stone. To change it,
-you need only edit the Gemstash configuration found at `~/.gemstash/config.yml`:
-```yaml
-# ~/.gemstash/config.yml
----
-:rubygems_url: https://my.gem-source.local
-```
-
-Make sure to restart your Gemstash server after changing the config:
-```
-$ gemstash stop
-$ gemstash start
-```
-
-Once restarted, bundling against `http://localhost:9292` will fetch gems from
-`https://my.gem-source.local`. If you had bundled before making these changes,
-fear not; bundling with a different default gem source will store gems in a
-separate location, ensuring different sources won't leak between each other.
-
-## Bundling with Multiple Sources
-
-Changing the default source won't help you if you need to bundle against
-https://www.rubygems.org along with additional sources. If you need to bundle
-with multiple gem sources, Gemstash doesn't need to be specially configured.
-Your Gemstash server will honor any gem source specified via a specialized URL.
-Consider the following `Gemfile`:
-```ruby
-# ./Gemfile
-require "cgi"
-source "http://localhost:9292"
-gem "rubywarrior"
-
-source "http://localhost:9292/upstream/#{CGI.escape("https://my.gem-source.local")}" do
-  gem "my-gem"
-end
-```
-
-Notice the `CGI.escape` call in the second source. This is important, as it
-properly URL escapes the source URL so Gemstash knows what gem source you want.
-The `/upstream` prefix tells Gemstash to use a gem source other than the default
-source. You can now bundle with the additional source.
-
-## Redirecting
-
-Gemstash supports an alternate mode of specifying your gem sources. If you want
-Gemstash to redirect Bundler to your given gem sources, then you can specify
-your `Gemfile` like so:
-```ruby
-# ./Gemfile
-require "cgi"
-source "http://localhost:9292/redirect/#{CGI.escape("https://www.rubygems.org")}"
-gem "rubywarrior"
-```
-
-Notice the `/redirect` prefix. This prefix tells Gemstash to redirect API calls
-to the provided URL. Redirected calls like this will not be cached by Gemstash,
-and gem files will not be stashed, even if they were previously cached or
-stashed from the same gem source.

data/docs/private_gems.md

@@ -1,140 +0,0 @@
-# Private Gems
-
-Stashing private gems in your Gemstash server requires a bit of additional
-setup. If you haven't read through the [Quickstart
-Guide](../README.md#quickstart-guide), you should do that first. By the end of
-this guide, you will be able to interact with your Gemstash server to store and
-retrieve your private gems.
-
-## Authorizing
-
-**IMPORTANT NOTE:** Do not use the actual key value in this document, otherwise
-your Gemstash server will be vulnerable to anyone who wants to try to use the
-key against your server. Instead of the key value here, use whatever key is
-generated from running the commands.
-
-In order to push a gem to your Gemstash server, you need to first create an API
-key. Utilize the `gemstash` command to create the API key:
-```
-$ gemstash authorize
-Your new key is: e374e237fdf5fa5718d2a21bd63dc911
-```
-
-This new key can `push`, `yank`, and `unyank` gems from your Gemstash server.
-Run `gemstash authorize` with just the permissions you want to limit what the
-key will be allowed to do. You can similarly update a specific key by providing
-it via the `--key` option:
-```
-$ gemstash authorize push yank --key e374e237fdf5fa5718d2a21bd63dc911
-```
-
-When no permissions are provided (like the first example), the key will be
-authorized for all permissions. Leave the key authorized with everything if you
-want to use it to try all private gem interactions:
-```
-$ gemstash authorize --key e374e237fdf5fa5718d2a21bd63dc911
-```
-
-With the key generated, you'll need to tell Rubygems about your new key. If
-you've pushed a gem to https://www.rubygems.org, then you will already have a
-credentials file to add the key to. If not, run the following commands before
-modifying the credentials file:
-```
-$ mkdir -p ~/.gem
-$ touch ~/.gem/credentials
-$ chmod 0600 ~/.gem/credentials
-```
-
-Add your new key to credentials such that it looks something like this (but make
-sure not to remove any existing keys):
-```yaml
-# ~/.gem/credentials
----
-:test_key: e374e237fdf5fa5718d2a21bd63dc911
-```
-
-The name `test_key` can be anything you want, but you will need to remember it
-and use it again later in this guide for the `--key` option.
-
-## Creating a Test Gem
-
-You'll need a test gem before you can play with private gems on your Gemstash
-server. If you have a gem you can use, move along to the next section. You can
-start by instantiating a test gem via Bundler:
-```
-$ bundle gem private-example
-```
-
-You'll need to add a summary and description to the new gem's gemspec file in
-order to successfully build it. Once you've built the gem, you will be ready to
-push the new gem.
-```
-$ cd private-example
-$ rake build
-```
-
-You will now have a gem at `private-example/pkg/private-example-0.1.0.gem`.
-
-## Pushing
-
-If your Gemstash server isn't running, go ahead and start it:
-```
-$ gemstash start
-```
-
-Push your test gem using Rubygems:
-```
-$ gem push --key test_key --host http://localhost:9292/private pkg/private-example-0.1.0.gem
-```
-
-The `/private` portion of the `--host` option tells Gemstash you are interacting
-with the private gems. Gemstash will not let you push, yank, or unyank from
-anything except `/private`.
-
-## Bundling
-
-Once your gem is pushed to your Gemstash server, you are ready to bundle it.
-Create a `Gemfile` and specify the gem. You will probably want to wrap the
-private gem in a source block, and let the rest of Gemstash handle all other
-gems:
-```ruby
-# ./Gemfile
-source "http://localhost:9292"
-gem "rubywarrior"
-
-source "http://localhost:9292/private" do
-  gem "private-example"
-end
-```
-
-Notice that the Gemstash server points to `/private` again when installing your
-private gem. Go ahead and bundle to install your new private gem:
-```
-$ bundle
-```
-
-## Yanking
-
-If you push a private gem by accident, you can yank the gem with Rubygems:
-```
-$ RUBYGEMS_HOST=http://localhost:9292/private gem yank --key test_key private-example --version 0.1.0
-```
-
-Like with pushing, the `/private` portion of the host option tells Gemstash you
-are interacting with private gems. Gemstash will only let you yank from
-`/private`. Unlike pushing, Rubygems doesn't support `--host` for yank and
-unyank (yet), so you need to specify the host via the `RUBYGEMS_HOST`
-environment variable.
-
-## Unyanking
-
-If you yank a private gem by accident, you can unyank the gem with Rubygems:
-```
-$ RUBYGEMS_HOST=http://localhost:9292/private gem yank --key test_key private-example --version 0.1.0 --undo
-```
-
-Like with pushing and yanking, the `/private` portion of the host option tells
-Gemstash you are interacting with private gems. Gemstash will only let you
-unyank from `/private`. Unlike pushing, Rubygems doesn't support `--host` for
-unyank and yank (yet), so you need to specify the host via the `RUBYGEMS_HOST`
-environment variable.