spore-rails 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 985a93a4a301bda8d488e2ab9ede61d18fc2728c
+  data.tar.gz: efd1c8554eb8368dbc2cd48709afedf77c4070a4
+SHA512:
+  metadata.gz: dec469cbed1e48a7d592dffb505700a23e433d829e2c0ac72dac2260cb585348820f86b7d8f38ca14f6b73f07d3ea032385a6447b7ba78bfb2c2bad6653a8929
+  data.tar.gz: c664cef26ddb8778a04ad230857ba9d67916db2ef6b60f2a56486fa06bd54e0728c7a4483a0b980497fe99fd81d7268aec3c49da29f7a727348a95430989d008

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Brandon Keepers
+
+MIT License
+
+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.md

@@ -0,0 +1,77 @@
+spore-rails
+-----------
+
+Ruby/Rails gem to load Spore environment variables. See the [Spore Website](https://spore.sh) for more information.
+
+
+## Installation
+
+### Rails
+
+Add this line to the top of your application's Gemfile:
+
+```ruby
+gem 'spore-rails'
+```
+
+And then execute:
+
+```shell
+$ bundle
+```
+
+#### Note on load order
+
+Spore is initialized in your Rails app during the `before_configuration` callback, which is fired when the `Application` constant is defined in `config/application.rb` with `class Application < Rails::Application`. If you need it to be initialized sooner, you can manually call `Spore::Railtie.load`.
+
+```ruby
+# config/application.rb
+Bundler.require(*Rails.groups)
+
+Spore::Railtie.load
+
+HOSTNAME = ENV['HOSTNAME']
+```
+
+If you use gems that require environment variables to be set before they are loaded, then list `spore-rails` in the `Gemfile` before those other gems and require `spore/rails-now`.
+
+```ruby
+gem 'spore-rails', :require => 'spore/rails-now'
+gem 'gem-that-requires-env-variables'
+```
+
+### Sinatra or Plain ol' Ruby
+
+Install the gem:
+
+```shell
+$ gem install spore
+```
+
+As early as possible in your application bootstrap process, load Spore:
+
+```ruby
+require 'spore'
+Spore.load
+```
+To ensure Spore is loaded in rake, load the tasks:
+
+```ruby
+require 'spore/tasks'
+
+task :mytask => :spore do
+    # things that require environment variables
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Notes
+
+The `spore-rails` gem was based on [`dotenv`](https://github.com/bkeepers/dotenv) by Brandon Keepers.

data/Rakefile

@@ -0,0 +1,4 @@
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r spore.rb"
+end

data/lib/spore/config.rb

@@ -0,0 +1,102 @@
+require 'spore-api'
+require 'netrc'
+
+module Spore
+  class Config
+    attr_reader :environment
+    attr_reader :api
+
+    DEPLOYMENT_VAR = "SPORE_DEPLOYMENT"
+    CONFIG_FILE = "config.json"
+    DEFAULT_CONFIG = File.expand_path(
+      "../config/default.json", File.dirname(__FILE__))
+
+    class << self
+      def is_deployment?
+        !ENV[DEPLOYMENT_VAR].nil?
+      end
+
+      def load
+        if is_deployment?
+          Spore::DeploymentConfig.new
+        else
+          Spore::LocalConfig.new
+        end
+      end
+    end
+
+    def config
+      @config ||= begin
+        file = File.read DEFAULT_CONFIG
+        hash  = JSON.parse file
+        config_file = File.join(ENV["SPORE_HOME"] || "~/.spore", CONFIG_FILE)
+        begin
+          hash.update(JSON.parse(File.read(File.expand_path(config_file))))
+        rescue Errno::ENOENT
+          # ~/.spore/config.json doesn't exist, so just use the default config
+          hash
+        end
+      end
+    end
+
+    def fetch(app_id, cell_id)
+      api.get_cell(app_id, environment, cell_id)["value"]
+    end
+
+    def spore_file
+      File.expand_path(config["sporeFile"])
+    end
+  end
+end
+
+module Spore
+  class LocalConfig < Config
+    def initialize
+      email, key = load_credentials
+      @api = Spore::Client.new
+      @api.key = key
+      @api.name = email
+      @api.api_endpoint = server
+    end
+
+    def environment
+      ENV["SPORE_ENV"] || @config["defaultEnv"]
+    end
+
+    def server
+      config["useProxy"] ? "http://127.0.0.1:#{config["proxy"]["port"]}" : config["host"]
+    end
+
+    private
+
+    def load_credentials
+      n = Netrc.read(File.expand_path config["netrc"])
+      hostname = URI.parse(config["host"]).hostname
+      n[hostname]
+    end
+  end
+end
+
+module Spore
+  class DeploymentConfig < Config
+    ENV_FORMAT = /(http|https):\/\/([a-zA-Z0-9-]+)\+([a-zA-Z0-9-]+)\+([a-f0-9-]+):([^@]+)@(.+)/
+
+    def initialize
+      ENV_FORMAT.match(ENV[Config::DEPLOYMENT_VAR]) do |m|
+        name = m[2]
+        key = m[5]
+        host = "#{m[1]}://#{m[6]}"
+        @environment = m[3]
+        @api = Spore::Client.new
+        @api.key = key
+        @api.name = name
+        @api.api_endpoint = host
+      end
+      raise "SPORE_DEPLOYMENT has an unexpected format" if @environment.nil?
+    end
+
+    def environment
+      ENV["SPORE_ENV"] || @environment
+    end
+  end
+end

data/lib/spore/environment.rb

@@ -0,0 +1,27 @@
+module Spore
+  # This class inherits from Hash and represents the environemnt into which
+  # Dotenv will load key value pairs from a file.
+  class Environment < Hash
+    attr_reader :filename
+
+    def initialize
+      load
+    end
+
+    def load
+      update Parser.call
+    end
+
+    def read
+      File.read(@filename)
+    end
+
+    def apply
+      each { |k, v| ENV[k] ||= v }
+    end
+
+    def apply!
+      each { |k, v| ENV[k] = v }
+    end
+  end
+end

data/lib/spore/parser.rb

@@ -0,0 +1,29 @@
+require 'json'
+
+module Spore
+  class Parser
+    class << self
+      def call
+        config = Spore::Config.load
+        new(config).hash
+      end
+    end
+
+    attr_reader :hash
+    def initialize(config)
+      @config = config
+      spore = JSON.parse(File.read config.spore_file)
+      translate(spore["id"], spore["envs"][config.environment])
+    end
+
+    def translate(app_id, hash)
+      @hash = {}
+      hash.each do |key, value|
+        # Translate APP_ENV to RAILS_ENV
+        key = "RAILS_ENV" if key == "APP_ENV"
+        @hash[key] = @config.fetch(app_id, value)
+      end
+      @hash
+    end
+  end
+end

data/lib/spore/rails-now.rb

@@ -0,0 +1,10 @@
+# If you use gems that require environment variables to be set before they are
+# loaded, then list `spore-rails` in the `Gemfile` before those other gems and
+# require `spore/rails-now`.
+#
+#     gem "spore-rails", :require => "spore/rails-now"
+#     gem "gem-that-requires-env-variables"
+#
+
+require "spore/rails"
+Spore::Railtie.load

data/lib/spore/rails.rb

@@ -0,0 +1,43 @@
+require "spore"
+
+Spore.instrumenter = ActiveSupport::Notifications
+
+# Watch all loaded env files with Spring
+begin
+  require "spring/watcher"
+  ActiveSupport::Notifications.subscribe(/^spore/) do |*args|
+    event = ActiveSupport::Notifications::Event.new(*args)
+    Spring.watch event.payload[:env].filename if Rails.application
+  end
+rescue LoadError
+  # Spring is not available
+end
+
+module Spore
+  # Spore Railtie for using Spore to load environment from a file into
+  # Rails applications
+  class Railtie < Rails::Railtie
+    config.before_configuration { load }
+
+    # Public: Load spore
+    #
+    # This will get called during the `before_configuration` callback, but you
+    # can manually call `Spore::Railtie.load` if you needed it sooner.
+    def load
+      Spore.load
+    end
+
+    # Internal: `Rails.root` is nil in Rails 4.1 before the application is
+    # initialized, so this falls back to the `RAILS_ROOT` environment variable,
+    # or the current working directory.
+    def root
+      Rails.root || Pathname.new(ENV["RAILS_ROOT"] || Dir.pwd)
+    end
+
+    # Rails uses `#method_missing` to delegate all class methods to the
+    # instance, which means `Kernel#load` gets called here. We don't want that.
+    def self.load
+      instance.load
+    end
+  end
+end

data/lib/spore/version.rb

@@ -0,0 +1,13 @@
+module Spore
+  class Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 3
+
+    class << self
+      def to_s
+        [MAJOR, MINOR, PATCH].join('.')
+      end
+    end
+  end
+end

data/lib/spore.rb

@@ -0,0 +1,31 @@
+require "spore/parser"
+require "spore/environment"
+require "spore/config"
+
+# The top level Spore module. The entrypoint for the application logic.
+module Spore
+  class << self
+    attr_accessor :instrumenter
+  end
+
+  module_function
+
+  def load(*filenames)
+    env = Environment.new
+    instrument("spore.load", :env => env) { env.apply }
+  end
+
+  # same as `load`, but will override existing values in `ENV`
+  def overload(*filenames)
+    env = Environment.new
+    instrument("spore.overload", :env => env) { env.apply! }
+  end
+
+  def instrument(name, payload = {}, &block)
+    if instrumenter
+      instrumenter.instrument(name, payload, &block)
+    else
+      block.call
+    end
+  end
+end

data/spore.gemspec

@@ -0,0 +1,18 @@
+require File.expand_path("../lib/spore/version", __FILE__)
+require "English"
+
+Gem::Specification.new "spore-rails", Spore::Version do |gem|
+  gem.authors       = ["Shayan Guha"]
+  gem.email         = ["shayan@teleborder.com"]
+  gem.description   = gem.summary = "Loads environment variables from spore."
+  gem.homepage      = "https://github.com/spore-sh/spore-rails"
+  gem.license       = "MIT"
+
+  gem.files = %w(LICENSE README.md Rakefile spore.gemspec)
+  gem.files += Dir.glob("lib/**/*.rb")
+  gem.require_paths = ["lib"]
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+
+  gem.add_dependency 'spore-api', "~> 0.0"
+  gem.add_dependency 'netrc', "~> 0.10"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: spore-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Shayan Guha
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: spore-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: netrc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Loads environment variables from spore.
+email:
+- shayan@teleborder.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/spore.rb
+- lib/spore/config.rb
+- lib/spore/environment.rb
+- lib/spore/parser.rb
+- lib/spore/rails-now.rb
+- lib/spore/rails.rb
+- lib/spore/version.rb
+- spore.gemspec
+homepage: https://github.com/spore-sh/spore-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Loads environment variables from spore.
+test_files: []
+has_rdoc: