ettin 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08cf35d041b4f0aa9bec85084709abc89591eff6
+  data.tar.gz: 3dabdab0049ec9b7f05c600c98edb62d46edc258
+SHA512:
+  metadata.gz: e13bc2b94e3961366bb05cbb6b1e4cfe0ef94c1ac0c2059a92d8c2426e3d438d19fb75ad57c88d4bf25c9883d6f10e54d3eef71c82f4c8f350e55ef786ccef55
+  data.tar.gz: 5302d5cfd460c68789b268ce57f210399fc5d7d6f953b1eb69dc47e1a35bb3352d5a336c658180624a539323c641d0b791d2acaeaeb2d6d51790dadf396d261b

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# Ignore because we're a gem
+/Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,143 @@
+inherit_from: .rubocop_todo.yml
+
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.3
+  Exclude:
+    - '*.gemspec'
+
+Naming/FileName:
+  ExpectMatchingDefinition: true
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/*/version.rb'
+
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+
+# We disable this cop because we want to use Pathname#/
+# and this cop is not configurable at all.
+Layout/SpaceAroundOperators:
+  Enabled: false
+
+Security/YAMLLoad:
+  Exclude:
+    - 'spec/**/*'
+
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+
+Metrics/LineLength:
+  Max: 100
+  AllowHeredoc: true
+  AllowURI: true
+  URISchemes:
+    - http
+    - https
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*_spec.rb'
+
+Layout/ElseAlignment:
+  Enabled: false
+
+Layout/FirstParameterIndentation:
+  EnforcedStyle: consistent
+
+Layout/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/CaseIndentation:
+  EnforcedStyle: end
+
+Layout/ClosingParenthesisIndentation:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: nested
+
+Style/CommentAnnotation:
+  Enabled: false
+
+# Does not work for multi-line copyright notices.
+Style/Copyright:
+  Enabled: false
+
+Layout/EmptyLineBetweenDefs:
+  AllowAdjacentOneLineDefs: true
+
+# These two cops do not differentiate between the scope the file is describing
+# and any namespaces it is nested under.  If this is not acceptable,
+# no_empty_lines produces the least offensive results.
+Layout/EmptyLinesAroundClassBody:
+  Enabled: false
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+# Produces poor results.
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Layout/IndentArray:
+  EnforcedStyle: consistent
+
+Layout/IndentHash:
+  EnforcedStyle: consistent
+
+Layout/AlignHash:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+  EnforcedLastArgumentHashStyle: always_ignore
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Layout/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+# Produces poor results.
+Style/Next:
+  Enabled: false
+
+Style/RedundantReturn:
+  AllowMultipleReturnValues: true
+
+Style/RegexpLiteral:
+  AllowInnerSlashes: true
+
+Style/Semicolon:
+  AllowAsExpressionSeparator: true
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Layout/SpaceInsideBlockBraces:
+  SpaceBeforeBlockParameters: false
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Lint/BlockAlignment:
+  EnforcedStyleAlignWith: start_of_block
+  #EnforcedStyleAlignWith: start_of_line
+
+Lint/EndAlignment:
+  EnforcedStyleAlignWith: start_of_line
+
+Lint/DefEndAlignment:
+  EnforcedStyleAlignWith: def
+
+Performance/RedundantMerge:
+  Enabled: false
+
+Style/WordArray:
+  EnforcedStyle: brackets
+

data/.travis.yml

@@ -0,0 +1,28 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4
+  - 2.3
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  global:
+    - CC_TEST_REPORTER_ID=dfb947d165289cdfab764c2f143dc0b5097878f4100b5580cca3b06932e04840
+
+before_install: gem install bundler
+
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+
+script:
+    - bundle exec rspec --order=random
+
+after_script:
+    - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT || true
+

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ettin.gemspec
+gemspec
+
+group :development do
+  gem "rake"
+  gem "rubocop"
+end
+
+group :test do
+  gem "simplecov", require: false
+end

data/LICENSE.md

@@ -0,0 +1,27 @@
+Copyright (c) 2018, The Regents of the University of Michigan.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of the The University of Michigan nor the
+  names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS OF THE UNIVERSITY OF MICHIGAN AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
+NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE
+UNIVERSITY OF MICHIGAN BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO,PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,211 @@
+# Ettin
+
+[![Build Status](https://travis-ci.org/mlibrary/ettin.svg?branch=master)](https://travis-ci.org/mlibrary/ettin)
+[![Maintainability](https://api.codeclimate.com/v1/badges/efd34b151bad7dacb994/maintainability)](https://codeclimate.com/github/mlibrary/ettin/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/efd34b151bad7dacb994/test_coverage)](https://codeclimate.com/github/mlibrary/ettin/test_coverage)
+[![Dependency Status](https://gemnasium.com/badges/github.com/mlibrary/ettin.svg)](https://gemnasium.com/github.com/mlibrary/ettin)
+
+## Summary
+
+Ettin manages loading and accessing settings from your configuration files,
+in an environment-aware fashion. It has only a single dependency on `deep_merge`,
+and provides only the functionality you actually need. It does not monkey-patch
+ruby nor does it pollute the global namespace.
+
+## Why should I use this over other options?
+
+* Ettin has far fewer dependencies than the top configuration gems.
+* Ettin does not pollute the global namespace.
+* Ettin provides only the features you need; or, put another way, Ettin does
+  not offer you paths that should not be followed.
+* Ettin is just plain ruby. No magic. No DSL.
+* Ettin works _everywhere_.
+
+## Compatibility
+
+Ettin is compatible with every ruby version, library, and framework.  This is
+possible because it does not rely on any specific runtime enviroment rather
+than the availability of the ruby core and standard library.
+
+## Installation
+
+1. Add it to your bundle and install like any other gem.
+2. Ettin provides an executable that will create the recommended configuration
+   files for you. These files will be empty. You can also create them yourself,
+   or simply specify your own files when you load Ettin.
+
+   `bundle exec ettin -v -p some/path`
+
+## Loading Settings
+
+Ettin is just plain ruby. There's nothing special about the objects it
+creates or how it creates them.  As such, it's up to the application to
+decide how it provides access to the configuration object. That may seem
+scary or confusing, but it's not--it's just plain ruby.  A few examples
+are below:
+
+Assign to a global constant using the default files:
+
+```ruby
+Settings = Ettin.for(Ettin.settings_files("config", "development"))
+```
+
+Assign with custom files:
+
+```ruby
+Settings = Ettin.for("config/path/1.yml", "config/path/2.yml")
+```
+
+Declare and assign to a top-level module:
+
+```ruby
+module MyApp
+  class << self
+    def config
+      @config ||= Ettin.for(Ettin.settings_files("config"), ENV["MYAPP_ENV"])
+    end
+  end
+end
+```
+
+In a Rails initializer:
+
+```ruby
+Rails.application.configure do |config|
+  config.settings = Ettin.for(...)
+end
+```
+
+
+## Default / Recommended Configuration Files
+
+The provided ettin executable will create the following files,
+including a file for each environment of production, development,
+and test.
+
+The name of the environment is not special, so you can easily create more.
+
+    config/settings.yml
+    config/settings/#{environment}.yml
+    config/environments/#{environment}.yml
+
+    config/settings.local.yml
+    config/settings/#{environment}.local.yml
+    config/environments/#{environment}.local.yml
+
+Environment-specific settings take precedence over common, and the .local
+files take precedence over those. The local files are intendended to be gitignored.
+
+## Using the Settings
+
+### Access
+
+Entries are available via dot-notation:
+
+```ruby
+config.some_setting               #=> 5
+config.some.nested.setting        #=> "my nested string"
+```
+
+...or `[]` notation:
+
+```ruby
+config[:some_setting]             #=> 5
+config["some_setting"]            #=> 5
+config[:some][:nested][:setting]  #=> "my nested string"
+```
+
+When a setting is not present, the returned value will be `nil`. We find
+that this is what most people expect. If you'd like an exception to be
+thrown, you can use dot-notation with a bang added:
+
+
+```ruby
+config.some_missing_setting!      #=> raises a KeyError
+```
+
+### Assignment
+
+You can also change settings at runtime via a merge:
+
+```ruby
+config.some_setting               #=> 5
+config.merge!({some_setting: 22})
+config.some_setting               #=> 22
+```
+
+...or direction assignment:
+
+
+```ruby
+config.some_setting               #=> 5
+config.some_setting = 22
+config.some_setting               #=> 22
+```
+
+Both of these methods work for any level of nesting.
+
+
+### ERB
+
+In Ettin, YAML files support ERB by default.
+
+
+```ruby
+# in settings.yml
+
+redis:
+  hostname: <%= ENV["REDIS_HOST"] %>
+```
+
+### Environment-specific Configuration Files
+
+Environment-specific configuration files are supported. These files
+take precedence over the common configuration, as you'd expect.  The
+
+## FAQs
+
+### How can I reload the entire setting object?
+
+Ettin's settings object is just a plain ruby object, so you should simply
+assign your settings reference to something else.
+
+### Why these specific files?
+
+Ettin is designed to be an easy transition from users of
+[config](https://github.com/railsconfig/config). We also think that these
+locations are quite sensible.
+
+### How do I validate my settings?
+
+Validation is a concern that is driven by the application itself. Placing the
+responsibility for that validation in Ettin would violate the single-responsibility
+principle. You should validate the settings where they're used, such as in an
+initialization step.
+
+### How do I load environment variables into my settings?
+
+Just use ERB. See the
+[ERB docs](http://ruby-doc.org/stdlib-2.4.2/libdoc/erb/rdoc/ERB.html)
+for more information.
+
+### How can I pull in settings from another source?
+
+Ettin supports hashes and paths to yaml files out of the box. You can extend
+this support by creating a subclass of `Ettin::Source`. Your subclass will
+need to define `::handles?(target)`, make a call of `register(self)`, and
+define a `#load` method that returns a hash.
+
+
+## Authors
+
+* This project was inspired by [railsconfig](https://github.com/railsconfig/config).
+* The author and maintainer is [Bryan Hockey](https://github.com/malakai97)
+
+## License
+
+    Copyright (c) 2018 The Regents of the University of Michigan.
+    All Rights Reserved.
+    Licensed according to the terms of the Revised BSD License.
+    See LICENSE.md for details.
+

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/ettin

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ettin/config_files"
+require "fileutils"
+require "optparse"
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "Creates the standard, empty config files starting from the given path.\n" \
+    "Usage: ettin STARTPATH"
+
+  opts.on("-p", "--path STARTPATH", "The root under which the files will be created.") do |p|
+    options[:start_path] = p
+  end
+
+  opts.on("-v", "--[no-]verbose", "Print paths created") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!
+
+unless options[:start_path]
+  puts "The --path option is required"
+  puts parser
+  exit 1
+end
+
+["development", "production", "test"]
+  .map {|env| Ettin::ConfigFiles.for(root: options[:start_path], env: env) }
+  .flatten
+  .sort.reverse
+  .uniq
+  .each do |path|
+    path.parent.mkpath
+    FileUtils.touch path.to_s
+    puts path if options[:verbose]
+  end
+
+puts "" if options[:verbose]

data/ettin.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ettin/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ettin"
+  spec.version       = Ettin::VERSION
+  spec.authors       = ["Bryan Hockey"]
+  spec.email         = ["bhock@umich.edu"]
+
+  spec.summary       = %q{The best way to add settings in any ruby project.}
+  spec.description   = %q{Ettin handles loading environment-specific settings in an easy, simple,
+                          and maintainable manner with minimal dependencies or magic.}
+  spec.license       = "Revised BSD"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "deep_merge"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rspec"
+end

data/lib/ettin.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "ettin/version"
+require "ettin/options"
+require "ettin/hash_factory"
+require "ettin/config_files"
+
+# Ettin is the best way to add settings to
+# any ruby project.
+module Ettin
+  def self.settings_files(root, env)
+    ConfigFiles.for(root: root, env: env)
+  end
+
+  def self.for(*targets)
+    Options.new(HashFactory.new.build(targets))
+  end
+end

data/lib/ettin/config_files.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ettin
+
+  # The configuration files for a given root and environment
+  class ConfigFiles
+
+    # @param root [String|Pathname]
+    # @param env [String]
+    # @return [Array<Pathname>]
+    def self.for(root:, env:)
+      root = Pathname.new(root)
+      [
+        root/"settings.yml",
+        root/"settings"/"#{env}.yml",
+        root/"environments"/"#{env}.yml",
+        root/"settings.local.yml",
+        root/"settings"/"#{env}.local.yml",
+        root/"environments"/"#{env}.local.yml"
+      ]
+    end
+
+  end
+end

data/lib/ettin/deep_transform.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# This copyright notice applies to this file only.
+# The original source was taken from:
+# https://github.com/basecamp/deep_hash_transform
+#
+# Copyright (c) 2005-2014 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Ettin
+
+  # Contains the logic for deep transformation of hash keys
+  module DeepTransform
+    # Returns a new hash with all keys converted by the block operation.
+    # This includes the keys from the root hash and from all
+    # nested hashes.
+    #
+    #  hash = { person: { name: 'Rob', age: '28' } }
+    #
+    #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+    #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+    unless method_defined?(:deep_transform_keys)
+      def deep_transform_keys(&block)
+        result = {}
+        each do |key, value|
+          result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+        end
+        result
+      end
+    end
+
+    # Destructively convert all keys by using the block operation.
+    # This includes the keys from the root hash and from all
+    # nested hashes.
+    unless method_defined?(:deep_transform_keys!)
+      def deep_transform_keys!(&block)
+        keys.each do |key|
+          value = delete(key)
+          self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+        end
+        self
+      end
+    end
+  end
+end
+
+unless {}.respond_to?(:deep_transform_keys)
+  Hash.include Ettin::DeepTransform
+end

data/lib/ettin/hash_factory.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "deep_merge"
+require "ettin/deep_transform"
+require "ettin/source"
+require "ettin/key"
+
+module Ettin
+
+  # Loads and deeply merges targets into a hash structure.
+  class HashFactory
+    def build(*targets)
+      hash = Hash.new(nil)
+      targets
+        .flatten
+        .map {|target| Source.for(target) }
+        .map(&:load)
+        .map {|h| h.deep_transform_keys {|key| Key.new(key) } }
+        .each {|h| hash.deep_merge!(h, overwrite_arrays: true) }
+      hash
+    end
+  end
+end

data/lib/ettin/key.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ettin
+
+  # Internal hash key that handles strings and symbols as
+  # the same type.
+  class Key
+    def initialize(key)
+      @key = key
+    end
+
+    def inspect
+      to_sym.inspect
+    end
+
+    def class
+      Symbol
+    end
+
+    def to_s
+      key.to_s
+    end
+
+    def to_sym
+      to_s.to_sym
+    end
+
+    def eql?(other)
+      to_sym == other.to_s.to_sym
+    end
+    alias_method :==, :eql?
+
+    def hash
+      key.to_s.to_sym.hash
+    end
+
+    private
+
+    attr_reader :key
+
+  end
+end

data/lib/ettin/options.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "ettin/key"
+
+module Ettin
+
+  # An object that holds configuration settings / options
+  class Options
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@hash, :keys, :empty?
+
+    def initialize(hash)
+      @hash = hash
+      @hash.deep_transform_keys! {|key| key.to_s.to_sym }
+      @hash.default = nil
+    end
+
+    def method_missing(method, *args, &block)
+      super(method, *args, &block) unless respond_to?(method)
+      if bang?(method) && !key?(debang(method))
+        raise KeyError, "key #{debang(method)} not found"
+      else
+        self[debang(method)]
+      end
+    end
+
+    # We respond to:
+    # * all methods our parents respond to
+    # * all methods that are mostly alpha-numeric: /^[a-zA-Z_0-9]*$/
+    # * all methods that are mostly alpha-numeric + !: /^[a-zA-Z_0-9]*\!$/
+    def respond_to_missing?(method, include_all = false)
+      super(method, include_all) || /^[a-zA-Z_0-9]*\!?$/.match(method.to_s)
+    end
+
+    def key?(key)
+      hash.key?(Key.new(key))
+    end
+    alias_method :has_key?, :key?
+
+    def merge!(other)
+      hash.deep_merge!(other.to_h, overwrite_arrays: true)
+    end
+
+    def [](key)
+      convert(hash[Key.new(key)])
+    end
+
+    def []=(key, value)
+      hash[Key.new(key)] = value
+    end
+
+    def to_h
+      hash
+    end
+    alias_method :to_hash, :to_h
+
+    def eql?(other)
+      to_h == other.to_h
+    end
+    alias_method :==, :eql?
+
+    def each
+      hash.each {|k, v| yield k, convert(v) }
+    end
+
+    private
+
+    attr_reader :hash
+
+    def bang?(method)
+      method.to_s[-1] == "!"
+    end
+
+    def debang(method)
+      if bang?(method)
+        method.to_s.chop.to_sym
+      else
+        method
+      end
+    end
+
+    def convert(value)
+      case value
+      when Hash
+        Options.new(value)
+      when Array
+        value.map {|i| convert(i) }
+      else
+        value
+      end
+    end
+  end
+
+end

data/lib/ettin/source.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ettin
+  class Source
+    def self.for(target)
+      registry.find {|candidate| candidate.handles?(target) }
+        .new(target)
+    end
+
+    def self.registry
+      @@registry ||= []
+    end
+
+    def self.register(candidate)
+      registry.unshift(candidate)
+    end
+
+    def self.register_default(candidate)
+      registry << candidate
+    end
+
+    def load
+      raise NotImplementedError
+    end
+
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/sources/**/*.rb"].each {|f| require f }

data/lib/ettin/sources/hash_source.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "ettin/source"
+
+module Ettin
+  module Sources
+
+    # Config data from a ruby hash
+    class HashSource < Source
+      register(self)
+
+      def self.handles?(target)
+        target.is_a? Hash
+      end
+
+      def initialize(hash)
+        @hash = hash.is_a?(Hash) ? hash : {}
+      end
+
+      def load
+        hash
+      end
+
+      private
+
+      attr_reader :hash
+    end
+
+  end
+end

data/lib/ettin/sources/options_source.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "ettin/options"
+require "ettin/source"
+
+module Ettin
+  module Sources
+
+    # Config data from an Ettin::Options
+    class OptionsSource < Source
+      register(self)
+
+      def self.handles?(target)
+        target.is_a? Options
+      end
+
+      def initialize(options)
+        @hash = options.to_h
+      end
+
+      def load
+        hash
+      end
+
+      private
+
+      attr_reader :hash
+    end
+
+  end
+end

data/lib/ettin/sources/yaml_source.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "ettin/source"
+require "erb"
+require "yaml"
+
+module Ettin
+  module Sources
+
+    # Config data from a yaml file
+    class YamlSource < Source
+      register_default(self)
+
+      def self.handles?(_target)
+        true
+      end
+
+      def initialize(path)
+        @path = path
+      end
+
+      def load
+        return {} unless File.exist?(path)
+        begin
+          YAML.safe_load(ERB.new(File.read(path)).result) || {}
+        rescue Psych::SyntaxError => e
+          raise "YAML syntax error occurred while parsing #{@path}. " \
+            "Please note that YAML must be consistently indented using " \
+            "spaces. Tabs are not allowed. " \
+            "Error: #{e.message}"
+        end
+      end
+
+      private
+
+      attr_reader :path
+    end
+
+  end
+end

data/lib/ettin/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ettin
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: ettin
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bryan Hockey
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Ettin handles loading environment-specific settings in an easy, simple,
+                            and maintainable manner with minimal dependencies or magic.
+email:
+- bhock@umich.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/ettin
+- ettin.gemspec
+- lib/ettin.rb
+- lib/ettin/config_files.rb
+- lib/ettin/deep_transform.rb
+- lib/ettin/hash_factory.rb
+- lib/ettin/key.rb
+- lib/ettin/options.rb
+- lib/ettin/source.rb
+- lib/ettin/sources/hash_source.rb
+- lib/ettin/sources/options_source.rb
+- lib/ettin/sources/yaml_source.rb
+- lib/ettin/version.rb
+homepage: 
+licenses:
+- Revised BSD
+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.4.5.3
+signing_key: 
+specification_version: 4
+summary: The best way to add settings in any ruby project.
+test_files: []