giga-clean-kit 0.0.1

data/figaro-1.3.0/spec/figaro/application_spec.rb

@@ -0,0 +1,262 @@
+require "tempfile"
+
+module Figaro
+  describe Application do
+    before do
+      allow_any_instance_of(Application).to receive(:default_path) { "/path/to/app/config/application.yml" }
+      allow_any_instance_of(Application).to receive(: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 {
+          allow(application).to receive(: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 {
+          allow(application).to receive(: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 "handles an empty environment block" do
+        application = Application.new(path: yaml_to_path("development:"))
+
+        expect {
+          application.configuration
+        }.not_to raise_error
+      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
+        allow(application).to receive(:default_path) { path_1 }
+
+        expect {
+          allow(application).to receive(: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
+        allow(application).to receive(:default_environment) { "development" }
+
+        expect {
+          allow(application).to receive(:default_environment) { "test" }
+        }.to change {
+          application.configuration
+        }.from("foo" => "bar").to("foo" => "baz")
+      end
+    end
+
+    describe "#load" do
+      let!(:application) { Application.new }
+
+      before do
+        allow(application).to receive(: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
+
+        allow(application).to receive(: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
+        allow(application).to receive(:configuration) { { foo: "bar" } }
+
+        expect(application).to receive(:warn)
+
+        application.load
+      end
+
+      it "warns when a value isn't a string" do
+        allow(application).to receive(:configuration) { { "foo" => ["bar"] } }
+
+        expect(application).to receive(:warn)
+
+        application.load
+      end
+
+      it "allows nil values" do
+        allow(application).to receive(:configuration) { { "foo" => nil } }
+
+        expect {
+          application.load
+        }.not_to change {
+          ::ENV["foo"]
+        }
+      end
+    end
+  end
+end

data/figaro-1.3.0/spec/figaro/cli/heroku_set_spec.rb

@@ -0,0 +1,67 @@
+describe "figaro heroku:set" do
+  before do
+    create_directory("example")
+    cd("example")
+    write_file("config/application.yml", "foo: bar")
+  end
+
+  it "sends Figaro configuration to Heroku" do
+    run_command_and_stop("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_command_and_stop("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_command_and_stop("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_command_and_stop("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 "targets a specific Heroku git remote" do
+    run_command_and_stop("figaro heroku:set -r production")
+
+    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", "--remote=production"])
+  end
+
+  it "handles values with special characters" do
+    overwrite_file("config/application.yml", "foo: bar baz")
+
+    run_command_and_stop("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/figaro-1.3.0/spec/figaro/cli/install_spec.rb

@@ -0,0 +1,49 @@
+describe "figaro install" do
+  before do
+    create_directory("example")
+    cd("example")
+  end
+
+  it "creates a configuration file" do
+    run_command_and_stop("figaro install")
+
+    expect("config/application.yml").to be_an_existing_file
+  end
+
+  it "respects path" do
+    run_command_and_stop("figaro install -p env.yml")
+
+    expect("env.yml").to be_an_existing_file
+  end
+
+  context "with a .gitignore file" do
+    before do
+      write_file(".gitignore", <<-EOF)
+/foo
+/bar
+EOF
+    end
+
+    it "Git-ignores the configuration file if applicable" do
+      run_command_and_stop("figaro install")
+
+      expect(".gitignore").to have_file_content(%r(^/foo$))
+      expect(".gitignore").to have_file_content(%r(^/bar$))
+      expect(".gitignore").to have_file_content(%r(^/config/application\.yml$))
+    end
+
+    it "respects path" do
+      run_command_and_stop("figaro install -p env.yml")
+
+      expect(".gitignore").to have_file_content(%r(^/env\.yml$))
+    end
+  end
+
+  context "without a .gitignore file" do
+    it "doesn't generate a new .gitignore file" do
+      run_command_and_stop("figaro install")
+
+      expect(".gitignore").not_to be_an_existing_file
+    end
+  end
+end

data/figaro-1.3.0/spec/figaro/env_spec.rb

@@ -0,0 +1,195 @@
+describe Figaro::ENV do
+  subject(:env) { Figaro::ENV }
+
+  before do
+    ::ENV["HELLO"] = "world"
+    ::ENV["foo"] = "bar"
+  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
+
+      it "respects a stubbed plain method" do
+        allow(env).to receive(:bar) { "baz" }
+        expect(env.bar).to eq("baz")
+      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
+
+      it "respects a stubbed plain method" do
+        allow(env).to receive(:bar) { "baz" }
+        expect { expect(env.bar!).to eq("baz") }.not_to raise_error
+      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
+
+      it "respects a stubbed plain method" do
+        allow(env).to receive(:bar) { "baz" }
+        expect(env.bar?).to eq(true)
+      end
+    end
+
+    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 "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 "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 false if no ENV key matches" do
+        expect(env.respond_to?(:baz!)).to eq(false)
+      end
+    end
+
+    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 "returns false if no ENV key matches" do
+        expect(env.respond_to?(:baz=)).to eq(false)
+      end
+    end
+  end
+end

data/figaro-1.3.0/spec/figaro/rails/application_spec.rb

@@ -0,0 +1,41 @@
+module Figaro
+  module Rails
+    describe Application do
+      describe "#default_path" do
+        let!(:application) { Application.new }
+
+        it "defaults to config/application.yml in Rails.root" do
+          allow(::Rails).to receive(:root) { Pathname.new("/path/to/app") }
+
+          expect {
+            allow(::Rails).to receive(:root) { Pathname.new("/app") }
+          }.to change {
+            application.send(:default_path).to_s
+          }.from("/path/to/app/config/application.yml").to("/app/config/application.yml")
+        end
+
+        it "raises an error when Rails.root isn't set yet" do
+          allow(::Rails).to receive(:root) { nil }
+
+          expect {
+            application.send(:default_path)
+          }.to raise_error(RailsNotInitialized)
+        end
+      end
+
+      describe "#default_environment" do
+        let!(:application) { Application.new }
+
+        it "defaults to Rails.env" do
+          allow(::Rails).to receive(:env) { "development" }
+
+          expect {
+            allow(::Rails).to receive(:env) { "test" }
+          }.to change {
+            application.send(:default_environment).to_s
+          }.from("development").to("test")
+        end
+      end
+    end
+  end
+end