mguymon-figaro 0.7.0.1

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,13 @@
+module Figaro
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "figaro.load", before: :load_environment_config do
+        Figaro.load
+      end
+
+      rake_tasks do
+        load "figaro/rails/tasks.rake"
+      end
+    end
+  end
+end

data/lib/figaro/rails/tasks.rake

@@ -0,0 +1,6 @@
+namespace :figaro do
+  desc "Configure Heroku according to application.yml"
+  task :heroku, [:app] => :environment do |_, args|
+    Figaro::Tasks::Heroku.new(args[:app]).invoke
+  end
+end

data/lib/figaro/tasks.rb

@@ -0,0 +1,28 @@
+require "bundler"
+
+module Figaro
+  module Tasks
+    class Heroku < Struct.new(:app)
+      def invoke
+        heroku("config:set #{vars}")
+      end
+
+      def vars
+        Figaro.vars(environment)
+      end
+
+      def environment
+        heroku("run 'echo $RAILS_ENV'").chomp[/(\w+)\z/]
+      end
+
+      def heroku(command)
+        with_app = app ? " --app #{app}" : ""
+        `heroku #{command}#{with_app}`
+      end
+
+      def `(command)
+        Bundler.with_clean_env { super }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Figaro
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_configuration
+        copy_file("application.yml", "config/application.yml")
+      end
+
+      def ignore_configuration
+        if File.exists?(".gitignore")
+          append_to_file(".gitignore") do
+            <<-EOF.strip_heredoc
+
+            # Ignore application configuration
+            /config/application.yml
+            EOF
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# Add application configuration variables here, as shown below.
+#
+# PUSHER_APP_ID: "2954"
+# PUSHER_KEY: 7381a978f7dd7f9a1117
+# PUSHER_SECRET: abdc3b896a0ffb85d373
+# STRIPE_API_KEY: EdAvEPVEC3LuaTg5Q3z6WbDVqZlcBQ8Z
+# STRIPE_PUBLIC_KEY: pk_BRgD57O8fHja9HxduJUszhef6jCyS

data/spec/figaro/application_spec.rb

@@ -0,0 +1,244 @@
+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: ActiveSupport::StringInquirer.new("test"))
+
+        expect(application.environment).to eq("test")
+        expect(application.environment).not_to be_an(ActiveSupport::StringInquirer)
+      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
+        ::ENV.delete("foo")
+        ::ENV.delete("FIGARO_foo")
+
+        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 that have already been set externally" do
+        ::ENV["foo"] = "baz"
+
+        expect {
+          application.load
+        }.not_to change {
+          ::ENV["foo"]
+        }
+      end
+
+      it "sets keys that have already been set internally" do
+        application.load
+
+        application2 = Application.new
+        application2.stub(configuration: { "foo" => "baz" })
+
+        expect {
+          application2.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).once
+
+        application.load
+      end
+
+      it "warns when a value isn't a string" do
+        application.stub(configuration: { "foo" => ["bar"] })
+
+        expect(application).to receive(:warn).once
+
+        application.load
+      end
+    end
+  end
+end

data/spec/figaro/env_spec.rb

@@ -0,0 +1,177 @@
+require "spec_helper"
+
+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")
+  end
+
+  describe "#method_missing" do
+    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
+    end
+
+    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
+    end
+
+    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
+    end
+
+    context "setter methods" do
+      it "raises an error" do
+        expect { env.foo = "bar" }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe "#respond_to?" do
+    context "plain methods" do
+      context "when ENV has the key" do
+        it "is true for a lowercase method" 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 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 eq(true)
+          expect(env.respond_to?(:fOO)).to eq(true)
+        end
+      end
+
+      context "when ENV doesn't have the key" do
+        it "is true" do
+          expect(env.respond_to?(:baz)).to eq(true)
+        end
+      end
+    end
+
+    context "bang methods" do
+      context "when ENV has the key" do
+        it "is true for a lowercase method" 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 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 eq(true)
+          expect(env.respond_to?(:fOO!)).to eq(true)
+        end
+      end
+
+      context "when ENV doesn't have the key" do
+        it "is false" do
+          expect(env.respond_to?(:baz!)).to eq(false)
+        end
+      end
+    end
+
+    context "boolean methods" do
+      context "when ENV has the key" do
+        it "is true for a lowercase method" 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 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 eq(true)
+          expect(env.respond_to?(:fOO?)).to eq(true)
+        end
+      end
+
+      context "when ENV doesn't have the key" do
+        it "is true" do
+          expect(env.respond_to?(:baz?)).to eq(true)
+        end
+      end
+    end
+
+    context "setter methods" do
+      context "when ENV has the key" do
+        it "is false" do
+          expect(env.respond_to?(:foo=)).to eq(false)
+        end
+      end
+
+      context "when ENV doesn't have the key" do
+        it "is false" do
+          expect(env.respond_to?(:baz=)).to eq(false)
+        end
+      end
+    end
+  end
+end