seielit-figaro 1.1.2

data/lib/figaro/rails.rb

@@ -0,0 +1,7 @@
+# at require-time, we need Rails to be defined to initialize the railtie
+# and set the default adapter to the Rails::Application adapter
+if defined?(Rails)
+  require "figaro/rails/application"
+  require "figaro/rails/railtie"
+  Figaro.adapter = Figaro::Rails::Application
+end

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,10 @@
+module Figaro
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.before_configuration do
+        Figaro.load
+      end
+      config.file_watcher = nil
+    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/settings.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Figaro
+  #
+  # This class should be extended in your own application to provide a higher
+  # level API for use in your application.
+  #
+  # Your app shouldn't use ENV, Figaro.env not Settings#[]. It also shouldn't
+  # fiddle with data conversion in settings.
+  #
+  # class Settings < Figaro::Settings
+  #   requires :per_page # makes it fail on startup
+  #   requires :port,
+  #     :int
+  #
+  #   def per_page
+  #     self[:per_page].int
+  #   end
+  # end
+  #
+  class Settings
+    attr_reader :namespace
+
+    NAMESPACE_SEPARATOR = '__'.freeze
+
+    module ClassMethods
+      def [](key)
+        new(key)
+      end
+
+      def requires(key, type = nil)
+        setting = self[key]
+        if type
+          setting.as type,
+            raises: true
+        else
+          setting.value || raise(MissingKey, key)
+        end
+      end
+    end
+    extend ClassMethods
+
+    def initialize(namespace)
+      @namespace = [namespace]
+    end
+
+    def [](key)
+      self.class.new(namespace + [key])
+    end
+
+    def key
+      ns = namespace || []
+      ns.join NAMESPACE_SEPARATOR
+    end
+
+    def value
+      env.send key
+    end
+
+    def to_str
+      value
+    end
+
+    def to_s
+      value
+    end
+
+    def inspect
+      "Setting: #{key} => #{value.inspect}"
+    end
+
+    module DataTypes
+      FALSY_VALUES = %w[no off false disabled].freeze
+
+      NULLABLE_TYPES = {
+        int: method(:Integer),
+        float: method(:Float),
+        decimal: method(:BigDecimal),
+        string: ->(itself) { itself || raise(ArgumentError) }
+      }.freeze
+
+      class InvalidKey < Error
+        def initialize(setting, type)
+          super("Invalid configuration key: can't convert #{setting.inspect} to #{type}")
+        end
+      end
+
+      def as(type, raises: false)
+        case type
+        when :bool
+          bool
+        else
+          conversion = NULLABLE_TYPES[type]
+          conversion.call value
+        end
+      rescue ArgumentError, TypeError
+        raise InvalidKey.new(self, type) if raises
+      end
+
+      def bool
+        !FALSY_VALUES.include? value&.downcase
+      end
+
+      NULLABLE_TYPES.each do |method, _conversion|
+        define_method method do
+          as method
+        end
+
+        define_method "#{method}!" do
+          as method,
+            raises: true
+        end
+      end
+    end
+    include DataTypes
+
+    private
+    def env
+      Figaro.env
+    end
+  end
+end

data/seielit-figaro.gemspec

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+Gem::Specification.new do |gem|
+  gem.name    = "seielit-figaro"
+  gem.version = "1.1.2"
+
+  gem.author      = "Steve Richert"
+  gem.email       = "steve.richert@gmail.com"
+  gem.summary     = "Simple Rails app configuration"
+  gem.description = "Simple, Heroku-friendly Rails app configuration using ENV and a single YAML file (fork of https://github.com/laserlemon/figaro)"
+  gem.homepage    = "https://github.com/seielit/figaro"
+  gem.license     = "MIT"
+
+  gem.add_dependency "thor", "~> 0.14"
+
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "rake", "~> 10.4"
+
+  gem.files      = `git ls-files`.split($\)
+  gem.test_files = gem.files.grep(/^spec/)
+
+  gem.executables << "figaro"
+end

data/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