greenpeace 0.0.2 → 0.1.0

data/lib/greenpeace/environment.rb

@@ -1,22 +1,19 @@
 module Greenpeace
+  # Environment accessor object
   class Environment
     attr_reader :values
 
     def initialize(config)
       @values = {}
 
-      config.requirements.each do |requirement|
-        @values[requirement.identifier] = requirement.value
-      end
-
-      config.options.each do |option|
-        @values[option.identifier] = option.value
+      config.settings.each do |setting|
+        @values[setting.identifier] = setting.value
       end
     end
 
     def method_missing(method)
       value = method.to_s
-      if @values.has_key?(value)
+      if @values.key?(value)
         @values[value]
       else
         super

data/lib/greenpeace/railtie.rb

@@ -1,10 +1,13 @@
-module Greenpeace
-  class Railtie < ::Rails::Railtie
-    config.before_configuration do
-      path = ::Rails.root.join("config", "greenpeace.rb")
+if defined?(Rails)
+  module Greenpeace
+    # Railtie which hooks into the Rails initialization process to load the
+    # greenpeace configuration file and check for the environment before
+    # starting the rest of the application
+    class Railtie < ::Rails::Railtie
+      config.before_configuration do
+        path = ::Rails.root.join('config', 'greenpeace.rb')
 
-      if File.exists?(path)
-        require path
+        require path if File.exist?(path)
       end
     end
   end

data/lib/greenpeace/version.rb

@@ -1,3 +1,4 @@
+#:nodoc:
 module Greenpeace
-  VERSION = "0.0.2"
+  VERSION = '0.1.0'
 end

data/lib/greenpeace.rb

@@ -1,16 +1,72 @@
-require "greenpeace/railtie" if defined?(Rails)
-require "greenpeace/configuration/config"
-require "greenpeace/environment"
+require 'greenpeace/railtie'
+require 'greenpeace/version'
+require 'greenpeace/configuration/config'
+require 'greenpeace/environment'
 
+#
+# = Greenpeace
+#
+# Greenpeace is an environment checker for validating the environment
+# configuration values before starting your application. The Greenpeace module
+# works as the only point of contact and API with users of the library, for
+# both defining environment requirements and accessing the environment values
+# on runtime.
+#
+# == Configuring requirements
+#
+# Before starting your application, you need to define what you need in your
+# environment. To do this, you call the `configure` method, using the
+# requirements API to define what is needed (called requirements in Greenpeace
+# docs) and what may be provided (called options in Greenpeace docs):
+#
+#   Greenpeace.configure do |env|
+#     # Here you define your environment values
+#   end
+#
+# You can also pass in an optional environment which represents the current
+# runtime mode the application is running into. This is useful for defining
+# runtime mode-specific defaults, such as default values which are applied only
+# in development mode.
+#
+#   Greenpeace.configure(ENV['RAILS_ENV']) do |env|
+#     # Here you define your environment values. Any defaults which you define
+#     # here that match with the runtime mode in the RAILS_ENV value will be
+#     # applied.
+#   end
+#
+# Check the grenpeace/configuration/config file for additional documentation on
+# how the requirements and option API is used.
+#
+# == Accessing environment values
+#
+# You can access the environment values directly through the `Greenpeace.env`
+# object. This will provide accessor methods according to what you defined in
+# the configuration block above.
+#
+# For example, if you had a configuration block like the following:
+#
+#   Greenpeace.configure do |env|
+#     env.requires :database_url
+#
+#     env.requires :port, type: :int
+#   end
+#
+# Then you could access the following variables:
+#
+#   Greenpeace.env.database_url
+#   Greenpeace.env.port
+#
+# The main advantage over using the standard `ENV` hash is that Greenpeace
+# performs type conversion. In the previous example, the `Greenpeace.env.port`
+# method returns an integer, not a string.
 module Greenpeace
-  def self.configure
-    configuration = Greenpeace::Configuration::Config.new
-    yield configuration
-    @@env = Greenpeace::Environment.new(configuration)
-  end
+  class << self
+    attr_reader :env
 
-  def self.env
-    @@env
+    def configure(environment = 'production')
+      configuration = Greenpeace::Configuration::Config.new(environment)
+      yield configuration
+      @env = Greenpeace::Environment.new(configuration)
+    end
   end
 end
-

data/spec/integration/simple_requirement_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'greenpeace'
+
+describe Greenpeace do
+  it 'allows the user to define a simple requirement' do
+    ENV['KEY'] = 'value'
+
+    Greenpeace.configure do |env|
+      env.requires :key
+    end
+
+    expect(Greenpeace.env.key).to eq('value')
+  end
+
+  it 'allows the user to define a simple option' do
+    ENV['KEY'] = 'value'
+
+    Greenpeace.configure do |env|
+      env.may_have :key
+    end
+
+    expect(Greenpeace.env.key).to eq('value')
+  end
+
+  it 'allows the user to define a defaulted simple option' do
+    ENV['KEY'] = ''
+
+    Greenpeace.configure do |env|
+      env.may_have :key, default: 'somevalue'
+    end
+
+    expect(Greenpeace.env.key).to eq('somevalue')
+  end
+
+  it 'allows the user to define a typed requirement' do
+    ENV['KEY'] = '10'
+
+    Greenpeace.configure do |env|
+      env.requires :key, type: :int
+    end
+
+    expect(Greenpeace.env.key).to eq(10)
+  end
+
+  it 'allows the user to define a documented requirement' do
+    ENV['KEY'] = ''
+
+    expect { Greenpeace.configure { |env| env.requires :key, doc: 'DOC' } }
+      .to raise_error(/DOC/)
+  end
+
+  it 'allows the user to define a environment-defaulted requirement' do
+    ENV['KEY'] = ''
+
+    Greenpeace.configure('development') do |env|
+      env.requires :key, defaults: { development: 'value' }
+    end
+
+    expect(Greenpeace.env.key).to eq('value')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+def configure_env_value(value)
+  ENV['KEY'] = value
+end

data/spec/unit/configuration/config_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'greenpeace/configuration/config'
+
+describe Greenpeace::Configuration::Config do
+  describe '#requires' do
+    it 'adds a new setting' do
+      expect { subject.requires(:key) }
+        .to change { subject.settings.size }.from(0).to(1)
+    end
+
+    it 'adds a requirement' do
+      subject.requires(:key)
+
+      expect(subject.settings.first)
+        .to be_kind_of(Greenpeace::Configuration::Requirement)
+    end
+
+    it 'disallows duplicating keys' do
+      subject.requires(:key)
+
+      expect { subject.requires(:key) }.to raise_error
+    end
+  end
+
+  describe '#may_have' do
+    it 'adds a new setting' do
+      expect { subject.may_have(:key) }
+        .to change { subject.settings.size }.from(0).to(1)
+    end
+
+    it 'adds a requirement' do
+      subject.may_have(:key)
+
+      expect(subject.settings.first)
+        .to be_kind_of(Greenpeace::Configuration::Option)
+    end
+
+    it 'disallows duplicating keys' do
+      subject.may_have(:key)
+
+      expect { subject.may_have(:key) }.to raise_error
+    end
+  end
+
+end

data/spec/unit/configuration/default_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'greenpeace/configuration/default'
+
+describe Greenpeace::Configuration::Default do
+  let(:test_class) { Greenpeace::Configuration::Default }
+  let(:type) { double('type') }
+
+  describe '#initialize' do
+    context 'when no default is provided' do
+      subject { test_class.new(type, {}, :a, :as) }
+
+      it 'provides a default nil value' do
+        expect(subject.value('development')).to be_nil
+      end
+    end
+
+    context 'when a valid value is provided directly' do
+      subject { test_class.new(type, { a: 'a' }, :a, :as) }
+
+      it 'provides the value in the entry' do
+        allow(type).to receive(:valid_value?).and_return(true)
+
+        expect(subject.value('development')).to eq('a')
+      end
+    end
+
+    context 'when an invalid value is provided directly' do
+      subject { test_class.new(type, { a: 'a' }, :a) }
+
+      it 'raises an error' do
+        allow(type).to receive(:valid_value?).and_return(false)
+
+        expect { subject.value('development') }.to raise_error
+      end
+    end
+
+    context 'when a valid value is provided for an environment' do
+      subject { test_class.new(type, { as: { development: 'a' } }, :a, :as) }
+
+      before(:each) { allow(type).to receive(:valid_value?).and_return(true) }
+
+      it 'provides the value for the environment' do
+        expect(subject.value('development')).to eq('a')
+      end
+
+      it 'provides the value for the environment as a symbol' do
+        expect(subject.value(:development)).to eq('a')
+      end
+
+      it 'provides a default nil value for other environments' do
+        expect(subject.value('production')).to be_nil
+      end
+    end
+
+    context 'when an invalid value is provided for an environment' do
+      subject { test_class.new(type, { as: { development: 'a' } }, :a, :as) }
+
+      it 'raises an error' do
+        allow(type).to receive(:valid_value?).and_return(false)
+
+        expect { subject.value }.to raise_error
+      end
+    end
+  end
+
+  describe '#environment_value?' do
+    subject { test_class.new(type, { as: { development: 'a' } }, :a, :as) }
+
+    before(:each) { allow(type).to receive(:valid_value?).and_return(true) }
+
+    it 'returns true for the environment which has a value' do
+      expect(subject).to be_environment_value('development')
+    end
+
+    it 'returns true for the environment which has a value as a symbol' do
+      expect(subject).to be_environment_value(:development)
+    end
+
+    it 'returns false for other environments do' do
+      expect(subject).not_to be_environment_value('production')
+    end
+  end
+end

data/spec/unit/configuration/doc_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'greenpeace/configuration/doc'
+
+describe Greenpeace::Configuration::Doc do
+  let(:test_class) { Greenpeace::Configuration::Doc }
+
+  describe '#initialize' do
+    context 'when no doc string is provided' do
+      subject { test_class.new({}, :a) }
+
+      it 'provides an "Undefined" documentation' do
+        expect(subject.to_s).to eq('Undefined')
+      end
+    end
+
+    context 'when a nil doc string is provided' do
+      subject { test_class.new({ a: nil }, :a) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+
+    context 'when a non-string doc is provided' do
+      subject { test_class.new({ a: 1 }, :a) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+
+    context 'when a valid string doc is provided' do
+      subject { test_class.new({ a: 'a' }, :a) }
+
+      it 'provides the given string doc' do
+        expect(subject.to_s).to eq('a')
+      end
+    end
+  end
+end

data/spec/unit/configuration/key_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'greenpeace/configuration/key'
+
+describe Greenpeace::Configuration::Key do
+  let(:test_class) { Greenpeace::Configuration::Key }
+
+  describe '#initialize' do
+    context 'when a nil key is provided' do
+      subject { test_class.new(nil) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+
+    context 'when a non-symbol key is provided' do
+      subject { test_class.new('a') }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+  end
+
+  subject { test_class.new(:a) }
+
+  describe '#==' do
+    it 'returns true for equal instances' do
+      expect(subject).to eq(test_class.new(:a))
+    end
+
+    it 'returns false for different instances' do
+      expect(subject).not_to eq(test_class.new(:b))
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the key' do
+      expect(subject.to_s).to eq('a')
+    end
+  end
+
+  describe '#identifier' do
+    it 'returns the downcased key' do
+      expect(subject.identifier).to eq('a')
+    end
+  end
+
+  describe '#env_identifier' do
+    it 'returns the upcased key' do
+      expect(subject.env_identifier).to eq('A')
+    end
+  end
+end

data/spec/unit/configuration/option_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'greenpeace/configuration/option'
+
+describe Greenpeace::Configuration::Option do
+  subject do
+    Greenpeace::Configuration::Option.new(
+      :key,
+      { type: :int, doc: 'DOC', default: 5 },
+      'development')
+  end
+
+  describe '#identifier' do
+    it 'returns the stringified key' do
+      expect(subject.identifier).to eq('key')
+    end
+  end
+
+  describe '#value' do
+    context 'when an empty value is in the ENV' do
+      before(:each) { configure_env_value '' }
+
+      it 'returns the default value' do
+        expect(subject.value).to eq(5)
+      end
+    end
+
+    context 'when a nil value is in the ENV' do
+      before(:each) { configure_env_value nil }
+
+      it 'returns the default value' do
+        expect(subject.value).to eq(5)
+      end
+    end
+
+    context 'when a valid value is in the ENV' do
+      before(:each) { configure_env_value '10' }
+
+      it 'returns the value' do
+        expect(subject.value).to eq(10)
+      end
+    end
+
+  end
+
+end

data/spec/unit/configuration/requirement_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'greenpeace/configuration/requirement'
+
+describe Greenpeace::Configuration::Requirement do
+  subject do
+    Greenpeace::Configuration::Requirement.new(
+      :key,
+      { type: :int, doc: 'DOC', defaults: { development: 5 } },
+      'development')
+  end
+
+  describe '#identifier' do
+    it 'returns the stringified key' do
+      expect(subject.identifier).to eq('key')
+    end
+  end
+
+  describe '#value' do
+    context 'when the environment does not match the default' do
+      subject do
+        Greenpeace::Configuration::Requirement.new(
+          :key,
+          { type: :int, doc: 'DOC', defaults: { development: 5 } },
+          'production')
+      end
+
+      context 'when an empty value is in the ENV' do
+        before(:each) { configure_env_value '' }
+
+        it 'raises an error' do
+          expect { subject.value }.to raise_error
+        end
+      end
+
+      context 'when a nil value is in the ENV' do
+        before(:each) { configure_env_value nil }
+
+        it 'raises an error' do
+          expect { subject.value }.to raise_error
+        end
+      end
+
+      context 'when a valid value is in the ENV' do
+        before(:each) { configure_env_value '10' }
+
+        it 'returns the value' do
+          expect(subject.value).to eq(10)
+        end
+      end
+    end
+
+    context 'when the environment matches the default' do
+      subject do
+        Greenpeace::Configuration::Requirement.new(
+          :key,
+          { type: :int, doc: 'DOC', defaults: { development: 5 } },
+          'development')
+      end
+
+      context 'when an empty value is in the ENV' do
+        before(:each) { configure_env_value '' }
+
+        it 'returns the default value' do
+          expect(subject.value).to eq(5)
+        end
+      end
+
+      context 'when a nil value is in the ENV' do
+        before(:each) { configure_env_value nil }
+
+        it 'returns the default value' do
+          expect(subject.value).to eq(5)
+        end
+      end
+
+      context 'when a valid value is in the ENV' do
+        before(:each) { configure_env_value '10' }
+
+        it 'returns the value' do
+          expect(subject.value).to eq(10)
+        end
+      end
+    end
+  end
+end

data/spec/unit/configuration/type_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'greenpeace/configuration/type'
+
+describe Greenpeace::Configuration::Type do
+  let(:test_class) { Greenpeace::Configuration::Type }
+
+  describe '#initialize' do
+    context 'when no type is provided' do
+      subject { test_class.new({}, :a) }
+
+      it 'provides a default string type' do
+        expect(subject.to_s).to eq('string')
+      end
+    end
+
+    context 'when a nil type is provided' do
+      subject { test_class.new({ a: nil }, :a) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+
+    context 'when a non-symbol type is provided' do
+      subject { test_class.new({ a: 'string' }, :a) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+
+    context 'when an invalid type is provided' do
+      subject { test_class.new({ a: :invalid }, :a) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error
+      end
+    end
+  end
+
+  context 'for the string type' do
+    subject { test_class.new({ a: :string }, :a) }
+
+    describe '#valid_value?' do
+      it 'returns true for any string' do
+        expect(subject).to be_valid_value('anything')
+      end
+
+      it 'returns true for nil' do
+        expect(subject).to be_valid_value(nil)
+      end
+    end
+
+    describe '#convert' do
+      it 'converts the string to itself' do
+        expect(subject.convert('anything')).to eq('anything')
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns string' do
+        expect(subject.to_s).to eq('string')
+      end
+    end
+  end
+
+  context 'for the int type' do
+    subject { test_class.new({ a: :int }, :a) }
+
+    describe '#valid_value?' do
+      it 'returns false for any non-number' do
+        expect(subject).not_to be_valid_value('a50')
+      end
+
+      it 'returns true for any number' do
+        expect(subject).to be_valid_value(50)
+      end
+    end
+
+    describe '#convert' do
+      it 'converts the string to a number' do
+        expect(subject.convert('50')).to eq(50)
+      end
+
+      it 'raises an error if the string is not a number' do
+        expect { subject.convert('a50') }.to raise_error
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns int' do
+        expect(subject.to_s).to eq('int')
+      end
+    end
+  end
+end