figaro 0.7.0 → 1.0.0.rc1

data/lib/figaro/rails/application.rb

@@ -0,0 +1,21 @@
+module Figaro
+  module Rails
+    class Application < Figaro::Application
+      private
+
+      def default_path
+        rails_not_initialized! unless ::Rails.root
+
+        ::Rails.root.join("config", "application.yml")
+      end
+
+      def default_environment
+        ::Rails.env
+      end
+
+      def rails_not_initialized!
+        raise RailsNotInitialized
+      end
+    end
+  end
+end

data/lib/figaro/rails/railtie.rb

@@ -0,0 +1,9 @@
+module Figaro
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.before_configuration do
+        Figaro.load
+      end
+    end
+  end
+end

data/lib/generators/figaro/install/install_generator.rb

@@ -1,6 +1,6 @@
 module Figaro
   module Generators
-    class InstallGenerator < Rails::Generators::Base
+    class InstallGenerator < ::Rails::Generators::Base
       source_root File.expand_path("../templates", __FILE__)
 
       def create_configuration

data/lib/generators/figaro/install/templates/application.yml

@@ -1,7 +1,11 @@
-# Add application configuration variables here, as shown below.
+# Add configuration values here, as shown below.
 #
-# PUSHER_APP_ID: "2954"
-# PUSHER_KEY: 7381a978f7dd7f9a1117
-# PUSHER_SECRET: abdc3b896a0ffb85d373
-# STRIPE_API_KEY: EdAvEPVEC3LuaTg5Q3z6WbDVqZlcBQ8Z
-# STRIPE_PUBLIC_KEY: pk_BRgD57O8fHja9HxduJUszhef6jCyS
+# pusher_app_id: "2954"
+# pusher_key: 7381a978f7dd7f9a1117
+# pusher_secret: abdc3b896a0ffb85d373
+# stripe_api_key: sk_test_2J0l093xOyW72XUYJHE4Dv2r
+# stripe_publishable_key: pk_test_ro9jV5SNwGb1yYlQfzG17LHK
+#
+# production:
+#   stripe_api_key: sk_live_EeHnL644i6zo4Iyq4v1KdV9H
+#   stripe_publishable_key: pk_live_9lcthxpSIHbGwmdO941O1XVU

data/spec/figaro/application_spec.rb

@@ -0,0 +1,258 @@
+require "spec_helper"
+
+require "tempfile"
+
+module Figaro
+  describe Application do
+    before do
+      Application.any_instance.stub(
+        default_path: "/path/to/app/config/application.yml",
+        default_environment: "development"
+      )
+    end
+
+    describe "#path" do
+      it "uses the default" do
+        application = Application.new
+
+        expect(application.path).to eq("/path/to/app/config/application.yml")
+      end
+
+      it "is configurable via initialization" do
+        application = Application.new(path: "/app/env.yml")
+
+        expect(application.path).to eq("/app/env.yml")
+      end
+
+      it "is configurable via setter" do
+        application = Application.new
+        application.path = "/app/env.yml"
+
+        expect(application.path).to eq("/app/env.yml")
+      end
+
+      it "casts to string" do
+        application = Application.new(path: Pathname.new("/app/env.yml"))
+
+        expect(application.path).to eq("/app/env.yml")
+        expect(application.environment).not_to be_a(Pathname)
+      end
+
+      it "follows a changing default" do
+        application = Application.new
+
+        expect {
+          application.stub(default_path: "/app/env.yml")
+        }.to change {
+          application.path
+        }.from("/path/to/app/config/application.yml").to("/app/env.yml")
+      end
+    end
+
+    describe "#environment" do
+      it "uses the default" do
+        application = Application.new
+
+        expect(application.environment).to eq("development")
+      end
+
+      it "is configurable via initialization" do
+        application = Application.new(environment: "test")
+
+        expect(application.environment).to eq("test")
+      end
+
+      it "is configurable via setter" do
+        application = Application.new
+        application.environment = "test"
+
+        expect(application.environment).to eq("test")
+      end
+
+      it "casts to string" do
+        application = Application.new(environment: :test)
+
+        expect(application.environment).to eq("test")
+        expect(application.environment).not_to be_a(Symbol)
+      end
+
+      it "respects nil" do
+        application = Application.new(environment: nil)
+
+        expect(application.environment).to eq(nil)
+      end
+
+      it "follows a changing default" do
+        application = Application.new
+
+        expect {
+          application.stub(default_environment: "test")
+        }.to change {
+          application.environment
+        }.from("development").to("test")
+      end
+    end
+
+    describe "#configuration" do
+      def yaml_to_path(yaml)
+        Tempfile.open("figaro") do |file|
+          file.write(yaml)
+          file.path
+        end
+      end
+
+      it "loads values from YAML" do
+        application = Application.new(path: yaml_to_path(<<-YAML))
+foo: bar
+YAML
+
+        expect(application.configuration).to eq("foo" => "bar")
+      end
+
+      it "merges environment-specific values" do
+        application = Application.new(path: yaml_to_path(<<-YAML), environment: "test")
+foo: bar
+test:
+  foo: baz
+YAML
+
+        expect(application.configuration).to eq("foo" => "baz")
+      end
+
+      it "drops unused environment-specific values" do
+        application = Application.new(path: yaml_to_path(<<-YAML), environment: "test")
+foo: bar
+test:
+  foo: baz
+production:
+  foo: bad
+YAML
+
+        expect(application.configuration).to eq("foo" => "baz")
+      end
+
+      it "is empty when no YAML file is present" do
+        application = Application.new(path: "/path/to/nowhere")
+
+        expect(application.configuration).to eq({})
+      end
+
+      it "is empty when the YAML file is blank" do
+        application = Application.new(path: yaml_to_path(""))
+
+        expect(application.configuration).to eq({})
+      end
+
+      it "is empty when the YAML file contains only comments" do
+        application = Application.new(path: yaml_to_path(<<-YAML))
+# Comment
+YAML
+
+        expect(application.configuration).to eq({})
+      end
+
+      it "processes ERB" do
+        application = Application.new(path: yaml_to_path(<<-YAML))
+foo: <%= "bar".upcase %>
+YAML
+
+        expect(application.configuration).to eq("foo" => "BAR")
+      end
+
+      it "follows a changing default path" do
+        path_1 = yaml_to_path("foo: bar")
+        path_2 = yaml_to_path("foo: baz")
+
+        application = Application.new
+        application.stub(default_path: path_1)
+
+        expect {
+          application.stub(default_path: path_2)
+        }.to change {
+          application.configuration
+        }.from("foo" => "bar").to("foo" => "baz")
+      end
+
+      it "follows a changing default environment" do
+        application = Application.new(path: yaml_to_path(<<-YAML))
+foo: bar
+test:
+  foo: baz
+YAML
+        application.stub(default_environment: "development")
+
+        expect {
+          application.stub(default_environment: "test")
+        }.to change {
+          application.configuration
+        }.from("foo" => "bar").to("foo" => "baz")
+      end
+    end
+
+    describe "#load" do
+      let!(:application) { Application.new }
+
+      before do
+        application.stub(configuration: { "foo" => "bar" })
+      end
+
+      it "merges values into ENV" do
+        expect {
+          application.load
+        }.to change {
+          ::ENV["foo"]
+        }.from(nil).to("bar")
+      end
+
+      it "skips keys (and warns) that have already been set externally" do
+        ::ENV["foo"] = "baz"
+
+        expect(application).to receive(:warn)
+
+        expect {
+          application.load
+        }.not_to change {
+          ::ENV["foo"]
+        }
+      end
+
+      it "sets keys that have already been set internally" do
+        application.load
+
+        application.stub(configuration: { "foo" => "baz" })
+
+        expect {
+          application.load
+        }.to change {
+          ::ENV["foo"]
+        }.from("bar").to("baz")
+      end
+
+      it "warns when a key isn't a string" do
+        application.stub(configuration: { foo: "bar" })
+
+        expect(application).to receive(:warn)
+
+        application.load
+      end
+
+      it "warns when a value isn't a string" do
+        application.stub(configuration: { "foo" => ["bar"] })
+
+        expect(application).to receive(:warn)
+
+        application.load
+      end
+
+      it "allows nil values" do
+        application.stub(configuration: { "foo" => nil })
+
+        expect {
+          application.load
+        }.not_to change {
+          ::ENV["foo"]
+        }
+      end
+    end
+  end
+end

data/spec/figaro/cli/heroku_set_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+require "figaro/cli"
+
+describe "figaro heroku:set" do
+  before do
+    create_dir("example")
+    cd("example")
+    write_file("config/application.yml", "foo: bar")
+  end
+
+  it "sends Figaro configuration to Heroku" do
+    run_simple("figaro heroku:set")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args).to eq(["config:set", "foo=bar"])
+  end
+
+  it "respects path" do
+    write_file("env.yml", "foo: bar")
+
+    run_simple("figaro heroku:set -p env.yml")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args).to eq(["config:set", "foo=bar"])
+  end
+
+  it "respects environment" do
+    overwrite_file("config/application.yml", <<-EOF)
+foo: bar
+test:
+  foo: baz
+EOF
+
+    run_simple("figaro heroku:set -e test")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args).to eq(["config:set", "foo=baz"])
+  end
+
+  it "targets a specific Heroku app" do
+    run_simple("figaro heroku:set -a foo-bar-app")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args.shift).to eq("config:set")
+    expect(command.args).to match_array(["foo=bar", "--app=foo-bar-app"])
+  end
+
+  it "handles values with special characters" do
+    overwrite_file("config/application.yml", "foo: bar baz")
+
+    run_simple("figaro heroku:set")
+
+    command = commands.last
+    expect(command.name).to eq("heroku")
+    expect(command.args).to eq(["config:set", "foo=bar baz"])
+  end
+end

data/spec/figaro/env_spec.rb

@@ -1,64 +1,196 @@
 require "spec_helper"
 
-describe Figaro::Env do
-  subject(:env) { Figaro::Env.new }
+describe Figaro::ENV do
+  subject(:env) { Figaro::ENV }
 
   before do
-    ENV["HELLO"] = "world"
-    ENV["foo"] = "bar"
-  end
-
-  after do
-    ENV.delete("HELLO")
-    ENV.delete("foo")
+    ::ENV["HELLO"] = "world"
+    ::ENV["foo"] = "bar"
   end
 
   describe "#method_missing" do
-    it "makes ENV values accessible as lowercase methods" do
-      expect(env.hello).to eq("world")
-      expect(env.foo).to eq("bar")
+    context "plain methods" do
+      it "makes ENV values accessible as lowercase methods" do
+        expect(env.hello).to eq("world")
+        expect(env.foo).to eq("bar")
+      end
+
+      it "makes ENV values accessible as uppercase methods" do
+        expect(env.HELLO).to eq("world")
+        expect(env.FOO).to eq("bar")
+      end
+
+      it "makes ENV values accessible as mixed-case methods" do
+        expect(env.Hello).to eq("world")
+        expect(env.fOO).to eq("bar")
+      end
+
+      it "returns nil if no ENV key matches" do
+        expect(env.goodbye).to eq(nil)
+      end
+
+      it "respects a stubbed plain method" do
+        env.stub(bar: "baz")
+        expect(env.bar).to eq("baz")
+      end
     end
 
-    it "makes ENV values accessible as uppercase methods" do
-      expect(env.HELLO).to eq("world")
-      expect(env.FOO).to eq("bar")
+    context "bang methods" do
+      it "makes ENV values accessible as lowercase methods" do
+        expect(env.hello!).to eq("world")
+        expect(env.foo!).to eq("bar")
+      end
+
+      it "makes ENV values accessible as uppercase methods" do
+        expect(env.HELLO!).to eq("world")
+        expect(env.FOO!).to eq("bar")
+      end
+
+      it "makes ENV values accessible as mixed-case methods" do
+        expect(env.Hello!).to eq("world")
+        expect(env.fOO!).to eq("bar")
+      end
+
+      it "raises an error if no ENV key matches" do
+        expect { env.goodbye! }.to raise_error(Figaro::MissingKey)
+      end
+
+      it "respects a stubbed plain method" do
+        env.stub(bar: "baz")
+        expect { expect(env.bar!).to eq("baz") }.not_to raise_error
+      end
     end
 
-    it "makes ENV values accessible as mixed-case methods" do
-      expect(env.Hello).to eq("world")
-      expect(env.fOO).to eq("bar")
+    context "boolean methods" do
+      it "returns true for accessible, lowercase methods" do
+        expect(env.hello?).to eq(true)
+        expect(env.foo?).to eq(true)
+      end
+
+      it "returns true for accessible, uppercase methods" do
+        expect(env.HELLO?).to eq(true)
+        expect(env.FOO?).to eq(true)
+      end
+
+      it "returns true for accessible, mixed-case methods" do
+        expect(env.Hello?).to eq(true)
+        expect(env.fOO?).to eq(true)
+      end
+
+      it "returns false if no ENV key matches" do
+        expect(env.goodbye?).to eq(false)
+      end
+
+      it "respects a stubbed plain method" do
+        env.stub(bar: "baz")
+        expect(env.bar?).to eq(true)
+      end
     end
 
-    it "raises an error if no ENV key matches" do
-      expect { env.goodbye }.to raise_error(NoMethodError)
+    context "setter methods" do
+      it "raises an error for accessible, lowercase methods" do
+        expect { env.hello = "world" }.to raise_error(NoMethodError)
+        expect { env.foo = "bar" }.to raise_error(NoMethodError)
+      end
+
+      it "raises an error for accessible, uppercase methods" do
+        expect { env.HELLO = "world" }.to raise_error(NoMethodError)
+        expect { env.FOO = "bar" }.to raise_error(NoMethodError)
+      end
+
+      it "raises an error for accessible, mixed-case methods" do
+        expect { env.Hello = "world" }.to raise_error(NoMethodError)
+        expect { env.fOO = "bar" }.to raise_error(NoMethodError)
+      end
+
+      it "raises an error if no ENV key matches" do
+        expect { env.goodbye = "world" }.to raise_error(NoMethodError)
+      end
     end
   end
 
   describe "#respond_to?" do
-    context "when ENV has the key" do
-      it "is true for a lowercase method" do
-        expect(env.respond_to?(:hello)).to be_true
-        expect(env.respond_to?(:foo)).to be_true
+    context "plain methods" do
+      it "returns true for accessible, lowercase methods" do
+        expect(env.respond_to?(:hello)).to eq(true)
+        expect(env.respond_to?(:foo)).to eq(true)
+      end
+
+      it "returns true for accessible uppercase methods" do
+        expect(env.respond_to?(:HELLO)).to eq(true)
+        expect(env.respond_to?(:FOO)).to eq(true)
+      end
+
+      it "returns true for accessible mixed-case methods" do
+        expect(env.respond_to?(:Hello)).to eq(true)
+        expect(env.respond_to?(:fOO)).to eq(true)
+      end
+
+      it "returns true if no ENV key matches" do
+        expect(env.respond_to?(:baz)).to eq(true)
+      end
+    end
+
+    context "bang methods" do
+      it "returns true for accessible, lowercase methods" do
+        expect(env.respond_to?(:hello!)).to eq(true)
+        expect(env.respond_to?(:foo!)).to eq(true)
       end
 
-      it "is true for a uppercase method" do
-        expect(env.respond_to?(:HELLO)).to be_true
-        expect(env.respond_to?(:FOO)).to be_true
+      it "returns true for accessible uppercase methods" do
+        expect(env.respond_to?(:HELLO!)).to eq(true)
+        expect(env.respond_to?(:FOO!)).to eq(true)
       end
 
-      it "is true for a mixed-case key" do
-        expect(env.respond_to?(:Hello)).to be_true
-        expect(env.respond_to?(:fOO)).to be_true
+      it "returns true for accessible mixed-case methods" do
+        expect(env.respond_to?(:Hello!)).to eq(true)
+        expect(env.respond_to?(:fOO!)).to eq(true)
+      end
+
+      it "returns false if no ENV key matches" do
+        expect(env.respond_to?(:baz!)).to eq(false)
       end
     end
 
-    context "when ENV doesn't have the key" do
-      it "is true if Hash responds to the method" do
-        expect(env.respond_to?(:baz)).to be_false
+    context "boolean methods" do
+      it "returns true for accessible, lowercase methods" do
+        expect(env.respond_to?(:hello?)).to eq(true)
+        expect(env.respond_to?(:foo?)).to eq(true)
+      end
+
+      it "returns true for accessible uppercase methods" do
+        expect(env.respond_to?(:HELLO?)).to eq(true)
+        expect(env.respond_to?(:FOO?)).to eq(true)
+      end
+
+      it "returns true for accessible mixed-case methods" do
+        expect(env.respond_to?(:Hello?)).to eq(true)
+        expect(env.respond_to?(:fOO?)).to eq(true)
+      end
+
+      it "returns true if no ENV key matches" do
+        expect(env.respond_to?(:baz?)).to eq(true)
+      end
+    end
+
+    context "setter methods" do
+      it "returns false for accessible, lowercase methods" do
+        expect(env.respond_to?(:hello=)).to eq(false)
+        expect(env.respond_to?(:foo=)).to eq(false)
+      end
+
+      it "returns false for accessible uppercase methods" do
+        expect(env.respond_to?(:HELLO=)).to eq(false)
+        expect(env.respond_to?(:FOO=)).to eq(false)
+      end
+
+      it "returns false for accessible mixed-case methods" do
+        expect(env.respond_to?(:Hello=)).to eq(false)
+        expect(env.respond_to?(:fOO=)).to eq(false)
       end
 
-      it "is false if Hash doesn't respond to the method" do
-        expect(env.respond_to?(:[])).to be_true
+      it "returns false if no ENV key matches" do
+        expect(env.respond_to?(:baz=)).to eq(false)
       end
     end
   end