environment_config 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 94877d33ba5f427d4f5d7c8098a1b472c59a873ea53b037e661a5aa564b37e79
+  data.tar.gz: 8bd759e5b24c255952398bb3cb72776d0e49c7eb6618a77058b9a440c875ba09
+SHA512:
+  metadata.gz: 36f865ef45d16d05b5706048b41afb743ae5af8b30d43a0e4c45f0ae3aa9c1594030a432e9ab37442823bbf96f621420fb13ccf281b2f62dfab354e09d6c4804
+  data.tar.gz: 0afe62776474b2cc33e9be969133fdd507ecf9f6e01a5ef1c3f4f3c3278d326b9b64c279cb4618d99356f732d487aaf6d479c9bc966dc8f546052f303fae7a3f

data/.gitignore

@@ -0,0 +1,5 @@
+Gemfile.lock
+
+spec/examples.txt
+
+*.gem

data/.gitlab-ci.yml

@@ -0,0 +1,17 @@
+image: ruby:2.4.1
+
+variables:
+  SSH_AUTH_SOCK: "/ssh-agent"
+
+before_script:
+  - mkdir -p /root/.ssh && ssh-keyscan -H codevault.io > /root/.ssh/known_hosts 2>/dev/null
+  - bundle config jobs 8
+  - bundle install --path=/tmp/bundler --quiet
+
+rspec:
+  script:
+    - bundle exec rspec
+
+rubocop:
+  script:
+    - bundle exec rubocop

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  kp_cop:
+    - default.yml

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+## 1.2.0
+
+* Add support for complex datatypes via `json` and `yaml` parsers
+
+## 1.1.0
+
+* Add `EnvironmentConfig.ensure`, which is a more expressive way to
+  check the presence of environment variables without using them
+* Add `EnvironmentConfig.fetch_*` methods that will fetch a single
+  environment variable expecting the given type (e.g. `fetch_string`).
+* Improve error readout for unparsable integer
+
+## 1.0.1
+
+* Make method private that should never have been public
+    * The `store` and `fetch` methods are not really part of the public interface
+      of the config, however since `fetch` is equal to a method on hashes,
+      it is quite likely to be called by accident
+
+## 1.0.0
+
+* Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+git_source(:codevault) { |repo_name| "git@codevault.io:#{repo_name}.git" }
+
+# Specify your gem's dependencies in auth_connector.gemspec
+gemspec
+
+# Need to mention it here instead of gemspec, since we pull it from a git repo
+gem 'kp_cop', codevault: 'kaeuferportal/kp_cop'

data/README.md

@@ -0,0 +1,118 @@
+# EnvironmentConfig
+
+This gem provides a unified way to read configuration parameters
+from environment variables.
+
+
+## Usage
+
+You can load a configuration from the environment using a `load` block:
+
+```ruby
+config = EnvironmentConfig.load do |c|
+  c.string 'FOO'
+  c.integer 'BAR', 42
+end
+```
+
+If any required variable is missing, an error will be raised. Errors can be
+suppressed by providing a default value as second parameter.
+
+Albeit environment variables being string only, you can specify types when
+defining parameters:
+
+* `string`
+* `symbol`
+* `integer` (base 10 encoded)
+* `boolean` (only accepts `true` and `false`)
+* `string_list` (comma separated)
+* `json`
+* `yaml`
+
+Type conversions try to be strict and will throw an error, if the conversion
+can't be performed safely (e.g. an integer receiving `abc` will raise an error
+instead of parsing to `0`).
+
+Be mindful, that `json` and `yaml` allow you to pass rather complex configuration, but will not be able to validate the content beyond checking it is valid JSON/YAML.
+
+### Accessing values
+
+After building the configuration, your values will be available:
+
+* as methods on the config object
+* as hash with string keys using `to_string_hash`
+* as hash with symbol keys using `to_symbol_hash`
+
+All keys are lower cased, so `FOO_ARG` will become `config.foo_arg` or `config.to_string_hash['foo']`.
+
+### Avoiding prefix duplication
+
+For environment variables you will usually want to assign common prefixes, e.g.
+
+```bash
+export FOO_HOST=host
+export FOO_PASSWORD=password
+```
+
+Oftentimes you don't want to have those prefixes in your application config,
+so you can strip them using `strip_prefix`:
+
+```ruby
+# defining it
+foo_config = EnvironmentConfig.load(strip_prefix: 'FOO_') do |c|
+  c.string  'FOO_HOST', 'default_host'
+  c.string  'FOO_PASSWORD'
+  c.string  'OTHER_FOO_VALUE', 'test'
+end
+
+# using it
+foo_config.host # default_host
+foo_config.other_foo_value # test
+```
+
+### Accessing single values
+
+Sometimes you just want to fetch a few unrelated values from the environment,
+but not create a configuration object.
+
+There are fetch methods for all known types. For example:
+
+```ruby
+EnvironmentConfig.fetch_integer('MY_PORT')
+ => 42
+```
+
+### Expecting environment variables
+
+If you want to check the correct definition of environment variables that you do
+not consume yourself (e.g. you know that a gem will consume them), just use
+the `ensure` helper method:
+
+```ruby
+EnvironmentConfig.ensure do |c|
+  c.string  'MY_GEM_CONFIG_VALUE'
+  c.integer 'MY_GEM_OTHER_VALUE'
+end
+```
+
+### Integration with Rails
+
+One possible integration into a Rails application could look like this:
+
+```ruby
+# config/application.rb
+module MyRailsApp
+  class Application < Rails::Application
+    # ...
+
+    config.some_sub_configuration = EnvironmentConfig.load do |c|
+      c.string  'FOO_HOST', 'default_host'
+      c.string  'FOO_PASSWORD'
+      c.boolean 'SOME_BOOL', false
+    end
+  end
+end
+
+# somewhere else
+Rails.application.config.some_sub_configuration.foo
+```

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'environment_config'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require 'pry'
+Pry.start

data/environment_config.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'environment_config/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'environment_config'
+  spec.version       = EnvironmentConfig::VERSION
+  spec.authors       = ['Jan Sandbrink']
+  spec.email         = ['jan.sandbrink@kaeuferportal.de']
+
+  spec.summary       = 'Gem to unify reading configuration from env variables.'
+  spec.homepage      = 'https://codevault.io/kaeuferportal/environment_config'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+                                        .reject { |f| f.match(%r{^spec/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec', '~> 3.6'
+end

data/lib/environment_config.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'environment_config/builder'
+require 'environment_config/type_fetcher_methods'
+
+class EnvironmentConfig
+  include TypeFetcherMethods
+
+  class << self
+    # Accepts the same block as `load` does, but only validates
+    # the presence and type of environment variables. Does not return
+    # a configuration.
+    def ensure(&block)
+      load(&block)
+      nil
+    end
+
+    # Loads a configuration from environment variables as specified
+    # by the block given (using the environment config DSL)
+    def load(**options)
+      builder = Builder.new(**options)
+      yield builder
+      builder.config
+    end
+  end
+
+  def initialize
+    @store = {}
+  end
+
+  def method_missing(method_name, *_arguments, &block)
+    return fetch method_name if known_key?(method_name)
+
+    super
+  end
+
+  def respond_to_missing?(method_name, _include_private = false)
+    known_key?(method_name) || super
+  end
+
+  def to_h
+    # This method solely exists for purposes of "irb discoverability"
+    raise NotImplementedError,
+          'Please choose between to_string_hash and to_symbol_hash, ' \
+          'depending on the key type you want to get.'
+  end
+
+  def to_string_hash
+    @store.dup
+  end
+
+  def to_symbol_hash
+    @store.map { |k, v| [k.to_sym, v] }.to_h
+  end
+
+  def store(key, value)
+    @store[key.to_s] = value
+  end
+
+  private
+
+  def fetch(key)
+    @store[key.to_s]
+  end
+
+  def known_key?(key)
+    @store.key? key.to_s
+  end
+end

data/lib/environment_config/builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'environment_config/typed_env'
+require 'environment_config/types'
+
+class EnvironmentConfig
+  class Builder
+    attr_reader :config
+
+    def initialize(strip_prefix: nil)
+      @strip_prefix = strip_prefix
+      @config = EnvironmentConfig.new
+    end
+
+    def method_missing(method_name, *args)
+      if Types.known_type?(method_name)
+        type = method_name
+        key = args.shift
+        convert_and_store(type, key, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, *args)
+      Types.known_type?(method_name) || super
+    end
+
+    private
+
+    def convert_and_store(type, key, *args)
+      value = TypedEnv.fetch(type, key, *args)
+      store(key, value)
+    end
+
+    def store(key, value)
+      if @strip_prefix && key.start_with?(@strip_prefix)
+        key = key[@strip_prefix.size..-1]
+      end
+      config.store(key.downcase, value)
+    end
+  end
+end

data/lib/environment_config/type_fetcher_methods.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'environment_config/typed_env'
+require 'environment_config/types'
+
+class EnvironmentConfig
+  module TypeFetcherMethods
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def method_missing(method_name, *args)
+        type = type_of_fetch_method(method_name)
+        if type && Types.known_type?(type)
+          key = args.shift
+          TypedEnv.fetch(type, key, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, *_args)
+        type = type_of_fetch_method(method_name)
+        (type && Types.known_type?(type)) || super
+      end
+
+      private
+
+      def type_of_fetch_method(method_name)
+        match = /\Afetch_(.+)/.match(method_name)
+        return nil unless match
+
+        match[1]
+      end
+    end
+  end
+end

data/lib/environment_config/typed_env.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'environment_config/types'
+
+class EnvironmentConfig
+  class TypedEnv
+    class << self
+      def fetch(type, key, *args)
+        Types.convert(type, key, fetch_raw(key, *args))
+      end
+
+      private
+
+      def fetch_raw(key, *args)
+        ENV.fetch(key, *args)
+      rescue KeyError => e
+        raise e,
+              "Expected environment variable #{key} to be set, but was missing."
+      end
+    end
+  end
+end

data/lib/environment_config/types.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'environment_config/types/boolean'
+require 'environment_config/types/integer'
+require 'environment_config/types/json'
+require 'environment_config/types/string'
+require 'environment_config/types/string_list'
+require 'environment_config/types/symbol'
+require 'environment_config/types/yaml'
+
+require 'environment_config/types/type_error'
+
+class EnvironmentConfig
+  module Types
+    ALL = [
+      ::EnvironmentConfig::Types::Boolean,
+      ::EnvironmentConfig::Types::Integer,
+      ::EnvironmentConfig::Types::Json,
+      ::EnvironmentConfig::Types::String,
+      ::EnvironmentConfig::Types::StringList,
+      ::EnvironmentConfig::Types::Symbol,
+      ::EnvironmentConfig::Types::Yaml
+    ].freeze
+
+    class << self
+      def convert(type_name, key, value)
+        type = type_map.fetch(type_name.to_sym)
+        type.convert(value)
+      rescue Types::TypeError => e
+        raise ArgumentError,
+              "Environment variable #{key} could not be read as #{type_name}." \
+              " Expected: #{e.expected_message}" \
+              " Got: #{e.value}"
+      end
+
+      def type_names
+        type_map.keys
+      end
+
+      def known_type?(type_name)
+        type_map.key?(type_name.to_sym)
+      end
+
+      private
+
+      def type_map
+        @type_map ||= ALL.map { |type| [type.name, type] }.to_h
+      end
+    end
+  end
+end

data/lib/environment_config/types/boolean.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class EnvironmentConfig
+  module Types
+    class Boolean
+      BOOLEAN_VALUES = %w[true false].freeze
+
+      class << self
+        def name
+          :boolean
+        end
+
+        def convert(value)
+          # ensure compatibility when receiving correctly typed default value
+          value = value.to_s
+
+          unless BOOLEAN_VALUES.include?(value)
+            raise TypeError.new(BOOLEAN_VALUES.join('/'), value)
+          end
+
+          value == 'true'
+        end
+      end
+    end
+  end
+end

data/lib/environment_config/types/integer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class EnvironmentConfig
+  module Types
+    class Integer
+      class << self
+        def name
+          :integer
+        end
+
+        def convert(value)
+          Integer(value)
+        rescue ArgumentError
+          raise TypeError.new('base 10 integer', value)
+        end
+      end
+    end
+  end
+end

data/lib/environment_config/types/json.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'json'
+
+class EnvironmentConfig
+  module Types
+    class Json
+      class << self
+        def name
+          :json
+        end
+
+        def convert(value)
+          return value if value.is_a?(Array) || value.is_a?(Hash)
+          return nil if value.empty?
+
+          JSON.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/environment_config/types/string.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class EnvironmentConfig
+  module Types
+    class String
+      class << self
+        def name
+          :string
+        end
+
+        def convert(value)
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/environment_config/types/string_list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class EnvironmentConfig
+  module Types
+    class StringList
+      class << self
+        def name
+          :string_list
+        end
+
+        def convert(value)
+          return value if value.is_a? Array
+
+          value.split(',')
+        end
+      end
+    end
+  end
+end

data/lib/environment_config/types/symbol.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class EnvironmentConfig
+  module Types
+    class Symbol
+      class << self
+        def name
+          :symbol
+        end
+
+        def convert(value)
+          value.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/environment_config/types/type_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class EnvironmentConfig
+  module Types
+    class TypeError < StandardError
+      attr_reader :expected_message, :value
+
+      def initialize(expected_message, value)
+        @expected_message = expected_message
+        @value = value
+
+        super()
+      end
+    end
+  end
+end

data/lib/environment_config/types/yaml.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+class EnvironmentConfig
+  module Types
+    class Yaml
+      class << self
+        def name
+          :yaml
+        end
+
+        def convert(value)
+          return value if value.is_a?(Array) || value.is_a?(Hash)
+          return nil if value.empty?
+
+          YAML.safe_load(value)
+        end
+      end
+    end
+  end
+end

data/lib/environment_config/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class EnvironmentConfig
+  VERSION = '1.2.0'.freeze
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: environment_config
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Jan Sandbrink
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+description: 
+email:
+- jan.sandbrink@kaeuferportal.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- bin/console
+- environment_config.gemspec
+- lib/environment_config.rb
+- lib/environment_config/builder.rb
+- lib/environment_config/type_fetcher_methods.rb
+- lib/environment_config/typed_env.rb
+- lib/environment_config/types.rb
+- lib/environment_config/types/boolean.rb
+- lib/environment_config/types/integer.rb
+- lib/environment_config/types/json.rb
+- lib/environment_config/types/string.rb
+- lib/environment_config/types/string_list.rb
+- lib/environment_config/types/symbol.rb
+- lib/environment_config/types/type_error.rb
+- lib/environment_config/types/yaml.rb
+- lib/environment_config/version.rb
+homepage: https://codevault.io/kaeuferportal/environment_config
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Gem to unify reading configuration from env variables.
+test_files: []