mc-settings 0.1.2 → 0.2.0

data/codecov.yml

@@ -0,0 +1,29 @@
+codecov:
+  require_ci_to_pass: no
+
+  notify:
+    wait_for_ci: yes
+
+parsers:
+  v1:
+    include_full_missed_files: true # To use with Ruby so we see files that have NO tests written
+
+coverage:
+  range: 50..75
+  round: down
+  precision: 1
+  status:
+    project:
+      default: off
+      settings:
+        target: 70%
+        threshold: 10%
+        informational: true
+        if_not_found: success
+        if_ci_failed: error
+        paths:
+          - lib/
+flags:
+  settings:
+    paths:
+      - lib/

data/lib/mc-settings/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Setting
+  VERSION = '0.2.0'
+end

data/lib/setting.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require 'yaml'
+require 'erb'
 
 class Hash
   def recursive_merge!(other)
     other.keys.each do |k|
       if self[k].is_a?(Array) && other[k].is_a?(Array)
-        self[k] += other[k]
+        self[k] = other[k]
       elsif self[k].is_a?(Hash) && other[k].is_a?(Hash)
         self[k].recursive_merge!(other[k])
       else
@@ -18,91 +21,103 @@ end
 
 class Setting
   class NotFound < RuntimeError; end
+
   class FileError < RuntimeError; end
+
   class AlreadyLoaded < RuntimeError; end
 
   include Singleton
-
   attr_reader :available_settings
 
-  # This method can be called only once.
-  #
-  # Parameter hash looks like this:
-  #
-  #  {  :files => [ "file1.yml", "file2.yml", ...],
-  #     :path  => "/var/www/apps/my-app/current/config/settings",
-  #     :local => true }
-  #
-  # If :local => true is set, we will load all *.yml files under :path/local directory
-  # after all files in :files have been loaded.  "Local" settings thus take precedence
-  # by design.  See README for more details.
-  #
-  def self.load(args = {})
-    raise AlreadyLoaded.new('Settings already loaded') if self.instance.loaded?
-    self.instance.load(args)
-  end
+  class << self
+    # This method can be called only once.
+    #
+    # Parameter hash looks like this:
+    #
+    #  {  :files => [ "file1.yml", "file2.yml", ...],
+    #     :path  => "/var/www/apps/my-app/current/config/settings",
+    #     :local => true }
+    #
+    # If :local => true is set, we will load all *.yml files under :path/local directory
+    # after all files in :files have been loaded.  "Local" settings thus take precedence
+    # by design.  See README for more details.
+    #
+    def load(**args)
+      raise AlreadyLoaded, 'Settings already loaded' if instance.loaded?
+
+      instance.load(**args)
+    end
 
-  def self.reload(args = {})
-    self.instance.load(args)
-  end
+    def reload(**args)
+      instance.load(**args)
+    end
 
-  # In Method invocation syntax we collapse Hash values
-  # and return a single value if 'default' is found among keys
-  # or Hash has only one key/value pair.
-  #
-  # For example, if the YML data is:
-  # tax:
-  #   default: 0.0
-  #   california: 7.5
-  #
-  # Then calling Setting.tax returns "0.0""
-  #
-  # This is the preferred method of using settings class.
-  #
-  def self.method_missing(method, *args, &block)
-    self.instance.value_for(method, args) do |v, args|
-      self.instance.collapse_hashes(v, args)
+    # In Method invocation syntax we collapse Hash values
+    # and return a single value if 'default' is found among keys
+    # or Hash has only one key/value pair.
+    #
+    # For example, if the YML data is:
+    # tax:
+    #   default: 0.0
+    #   california: 7.5
+    #
+    # Then calling Setting.tax returns "0.0""
+    #
+    # This is the preferred method of using settings class.
+    #
+    def method_missing(method, *args)
+      instance.value_for(method, args) do |v, args|
+        instance.collapse_hashes(v, args)
+      end
     end
-  end
 
-  # In [] invocation syntax, we return settings value 'as is' without
-  # Hash conversions.
-  #
-  # For example, if the YML data is:
-  # tax:
-  #   default: 0.0
-  #   california: 7.5
-  #
-  # Then calling Setting['tax'] returns
-  #   { 'default' => "0.0", 'california' => "7.5"}
-
-  def self.[](value)
-    self.instance.value_for(value)
-  end
+    def respond_to_missing?
+      true
+    end
+
+    # In [] invocation syntax, we return settings value 'as is' without
+    # Hash conversions.
+    #
+    # For example, if the YML data is:
+    # tax:
+    #   default: 0.0
+    #   california: 7.5
+    #
+    # Then calling Setting['tax'] returns
+    #   { 'default' => "0.0", 'california' => "7.5"}
+
+    def [](value)
+      instance.value_for(value)
+    end
 
-  # <b>DEPRECATED:</b> Please use <tt>method accessors</tt> instead.
-  def self.available_settings
-    self.instance.available_settings
+    # <b>DEPRECATED:</b> Please use <tt>method accessors</tt> instead.
+    def available_settings
+      instance.available_settings
+    end
   end
 
-  #=================================================================
   # Instance Methods
-  #=================================================================
 
   def initialize
-    @available_settings ||= {}
+    @available_settings = {}
   end
 
-  def has_key?(key)
-    @available_settings.has_key?(key) ||
-      (key[-1,1] == '?' && @available_settings.has_key?(key.chop))
+  # @param [Object] key
+  def key?(key)
+    @available_settings.key?(key) ||
+      (key[-1, 1] == '?' && @available_settings.key?(key.chop))
   end
 
+  alias has_key? key?
+
   def value_for(key, args = [])
     name = key.to_s
-    raise NotFound.new("#{name} was not found") unless has_key?(name)
+    unless key?(name)
+      raise NotFound, "#{name} was not found"
+    end
+
     bool = false
-    if name[-1,1] == '?'
+    if name[-1, 1] == '?'
       name.chop!
       bool = true
     end
@@ -112,7 +127,7 @@ class Setting
       v = yield(v, args)
     end
 
-    if v.is_a?(Fixnum) && bool
+    if v.is_a?(Integer) && bool
       v.to_i > 0
     else
       v
@@ -121,59 +136,68 @@ class Setting
 
   # This method performs collapsing of the Hash settings values if the Hash
   # contains 'default' value, or just 1 element.
-  
+
   def collapse_hashes(v, args)
     out = if v.is_a?(Hash)
-      if args.empty?
-        if v.has_key?("default")
-          v['default'].nil? ? "" : v['default']
-        elsif v.keys.size == 1
-          v.values.first
-        else
-          v
-        end
-      else
-        v[args.shift.to_s]
-      end
-    else
-      v
-    end
-
-    if out.is_a?(Hash)
+            if args.empty?
+              if v.key?("default")
+                v['default'].nil? ? "" : v['default']
+              elsif v.keys.size == 1
+                v.values.first
+              else
+                v
+              end
+            else
+              v[args.shift.to_s]
+            end
+          else
+            v
+          end
+    if out.is_a?(Hash) && !args.empty?
       collapse_hashes(out, args)
+    elsif out.is_a?(Hash) && out.key?('default')
+      out['default']
     else
       out
     end
   end
-  
+
   def loaded?
     @loaded
   end
 
-  def load(params)
+  def load(**params)
     # reset settings hash
     @available_settings = {}
-    @loaded = false
+    @loaded             = false
 
     files = []
     path  = params[:path] || Dir.pwd
     params[:files].each do |file|
       files << File.join(path, file)
     end
-
     if params[:local]
-      files << Dir.glob(File.join(path, 'local', '*.yml'))
+      files << Dir.glob(File.join(path, 'local', '*.yml')).sort
     end
 
     files.flatten.each do |file|
-      begin
-        @available_settings.recursive_merge!(YAML::load(File.open(file)) || {}) if File.exists?(file)
-      rescue Exception => e
-        raise FileError.new("Error parsing file #{file}, with: #{e.message}")
+      if File.exist?(file)
+        @available_settings.recursive_merge! load_file(file)
       end
+    rescue StandardError => e
+      raise FileError, "Error parsing file #{file}, with: #{e.message}"
     end
 
     @loaded = true
     @available_settings
   end
+
+  private
+
+  def load_file(file)
+    ::YAML.load(
+      ::ERB.new(::IO.read(file)).result,
+      fallback: {},
+    )
+  end
 end

data/mc-settings.gemspec

@@ -1,72 +1,33 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require_relative 'lib/mc-settings/version'
 
 Gem::Specification.new do |s|
-  s.name = %q{mc-settings}
-  s.version = "0.1.2"
+  s.name                      = 'mc-settings'
+  s.version                   = Setting::VERSION
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Edwin Cruz", "Colin Shield"]
-  s.date = %q{2011-01-18}
-  s.description = %q{implement custom keys indenendently of environment}
-  s.email = %q{rubydev@modcloth.com}
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE.txt",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION",
-    "lib/mc-settings.rb",
-    "lib/setting.rb",
-    "mc-settings.gemspec",
-    "spec/fixtures/joes-colors.yml",
-    "spec/fixtures/sample.yml",
-    "spec/mc_settings_spec.rb",
-    "spec/spec_helper.rb",
-    "spec/support/settings_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/modcloth/mc-settings}
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Manage settings per environment}
-  s.test_files = [
-    "spec/mc_settings_spec.rb",
-    "spec/spec_helper.rb",
-    "spec/support/settings_helper.rb"
-  ]
+  s.authors                   = ["Edwin Cruz", "Colin Shield", "Konstantin Gredeskoul"]
+  s.date                      = '2020-09-01'
+  s.description               = 'Manage application configuration and settings per deployment environment'
+  s.summary                   = 'Manage application configuration and settings per deployment environment'
+  s.email                     = %w[softr8@gmail.com kigster@gmail.com]
+  s.files                     = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.extra_rdoc_files          = %w[LICENSE.txt README.adoc]
+  s.homepage                  = 'https://github.com/kigster/mc-settings'
+  s.licenses                  = ["MIT"]
+  s.require_paths             = ["lib"]
+  s.test_files                = %w[spec/mc_settings_spec.rb spec/spec_helper.rb spec/support/settings_helper.rb]
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.5.1"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
-      s.add_development_dependency(%q<ruby-debug>, [">= 0"])
-    else
-      s.add_dependency(%q<rspec>, [">= 0"])
-      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
-      s.add_dependency(%q<rcov>, [">= 0"])
-      s.add_dependency(%q<ruby-debug>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rspec>, [">= 0"])
-    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
-    s.add_dependency(%q<rcov>, [">= 0"])
-    s.add_dependency(%q<ruby-debug>, [">= 0"])
-  end
+  s.add_development_dependency('bundler')
+  s.add_development_dependency('rspec', '~> 3.0')
+  s.add_development_dependency('simplecov')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('pry-byebug')
+  s.add_development_dependency('rspec-mocks')
+  s.add_development_dependency('asciidoctor')
+  s.add_development_dependency('rspec-expectations')
 end
-

data/spec/mc_settings_spec.rb

@@ -1,64 +1,76 @@
+# frozen_string_literal: true
+
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'mc-settings'
 describe Setting do
-  subject { Setting }
+  subject { described_class }
 
   context "Test with stubs" do
     before :each do
       stub_setting_files
-      Setting.reload(
-          :path  => "config/settings",
-          :files => ["default.yml", "environments/test.yml"],
-          :local => true)
+      subject.reload(
+        path:  "config/settings",
+        files: %w[default.yml environments/test.yml],
+        local: true
+      )
     end
 
     it 'should return test specific values' do
-      Setting.available_settings['one'].should == "test"
-      Setting.one.should == "test"
-      Setting['one'].should == "test"
+      expect(subject.available_settings['one']).to eql "test"
+      expect(subject.one).to eql "test"
+      expect(subject['one']).to eql "test"
     end
 
     it "should handle custom values overriding everything else" do
-      Setting.seven.should == "seven from custom"
+      expect(subject.seven).to eql "seven from custom"
     end
 
+    let(:six) { { "default" => "default value", "extra" => "recursively overriden", "deep_level" => { "value" => "even deeper level" } } }
+
     it "handles multiple values" do
-      Setting[:six].should == {"default"=>"default value", "extra"=>"recursively overriden", "deep_level"=>{"value"=>"even deeper level"}}
-      Setting.available_settings['six']['default'].should == "default value"
-      Setting.seven.should == "seven from custom"
+      expect(subject[:six]).to eql six
+      expect(subject.available_settings['six']['default']).to eql "default value"
+      expect(subject.seven).to eql "seven from custom"
     end
 
     it "handles default key" do
-      Setting.default_setting.should == 1
-      Setting['seven']['default'].should == "seven from custom"
+      expect(subject.default_setting).to eql 1
+      expect(subject['seven']['default']).to eql "seven from custom"
     end
 
     it "should handle empty strings" do
-      Setting.empty.should == ""
+      expect(subject.empty).to eql ""
     end
 
     it "should responds to ? mark" do
-      Setting.autologin?.should == true
+      expect(subject.autologin?).to eql true
     end
 
     it "should returns false correctly" do
-      Setting.flag_false.should be(false)
+      expect(subject.flag_false).to be_falsey
     end
 
-    it "should merge keys recursivelly" do
-      Setting.six(:extra).should == "recursively overriden"
-      Setting.six(:deep_level, :value).should == "even deeper level"
+    it "should merge keys recursively" do
+      expect(subject.six(:extra)).to eql "recursively overriden"
+      expect(subject.six(:deep_level, :value)).to eql "even deeper level"
     end
 
     it "should create keys if it does not exist" do
-      Setting.test_specific.should == "exist"
+      expect(subject.test_specific).to eql "exist"
+    end
+
+    context "working with arrays" do
+      it "should replace the whole array instead of appending new values" do
+        expect(subject.nested_array).to eql %w[first four five]
+      end
     end
   end
 
   context "When running with threads" do
     it "should keep its values" do
-      3.times do |time|
+      3.times do |_time|
         Thread.new {
-          Setting.available_settings.shoud_not be_empty
+          expect(subject.available_settings).not_to be_empty
         }
       end
     end
@@ -66,58 +78,84 @@ describe Setting do
 
   context "Test from file" do
     before :each do
-      Setting.reload(
-         :path  => File.join(File.dirname(__FILE__)) + '/fixtures',
-         :files => ['sample.yml']
+      subject.reload(
+        path:  File.join(File.dirname(__FILE__)) + '/fixtures',
+        files: ['sample.yml']
       )
     end
 
     it 'should support [] syntax' do
-      Setting['tax']['default'].should == 0.0
-      Setting['tax'].should == { 'default' => 0.0, 'california' => 7.5 }
+      expect(subject['tax']['default']).to eql 0.0
+      expect(subject['tax']).to eql( 'default' => 0.0, 'california' => 7.5 )
     end
 
     it 'should support method invocation syntax' do
-      Setting.tax.should == 0.0
-
-      Setting.tax(:default).should     == Setting.tax
-      Setting.tax('default').should    == Setting.tax
-      Setting.tax(:california).should  == 7.5
-
-      Setting.states.should            == ['CA', 'WA', 'NY']
-      Setting.states(:default).should  == Setting.states
-      Setting.states(:ship_to).should  == ['CA', 'NY']
+      expect(subject.tax).to eql 0.0
+      expect(subject.states).to eql  %w[CA WA NY]
+      expect(subject.tax(:default)).to eql subject.tax
+      expect(subject.tax('default')).to eql subject.tax
+      expect(subject.tax(:california)).to eql 7.5
+      expect(subject.states(:default)).to eql subject.states
+      expect(subject.states(:ship_to)).to eql %w[CA NY]
     end
 
     it 'should correctly process Boolean values' do
-      Setting.boolean_true?.should be(true)
-      Setting.boolean_true.should == 4
-      Setting.boolean_false?.should be(false)
-      Setting.boolean_false?(:default).should be(false)
-      Setting.boolean_false?(:negated).should be(true)
+      expect(subject.boolean_true?).to be_truthy
+      expect(subject.boolean_true).to eql 4
+      expect(subject.boolean_false?).to be_falsey
+      expect(subject.boolean_false?(:default)).to be_falsey
+      expect(subject.boolean_false?(:negated)).to be_truthy
     end
   end
 
   context "Test recursive overrides and nested hashes" do
     before :each do
-      Setting.reload(
-         :path  => File.join(File.dirname(__FILE__)) + '/fixtures',
-         :files => ['sample.yml', 'joes-colors.yml']
+      subject.reload(
+        path:  File.join(File.dirname(__FILE__)) + '/fixtures',
+        files: %w[sample.yml joes-colors.yml]
       )
     end
 
     it 'should override colors with Joes and support nested hashes' do
-      Setting.color.should == :grey # default
-      Setting.color(:pants).should == :purple # default
-
-      Setting.color(:pants, :school).should == :blue # in sample
-      Setting.color(:pants, :favorite).should == :orange # joes override
+      expect(subject.color).to eql :grey # default
+      expect(subject.color(:pants)).to eql :purple # default
+      expect(subject.color(:pants, :school)).to eql :blue # in sample
+      expect(subject.color(:pants, :favorite)).to eql :orange # joes override
+      expect(subject.color(:shorts,:school)).to eql :black # in sample
+      expect(subject.color(:shorts, :favorite)).to eql :white # joe's override
+      expect(subject.color(:shorts)).to  eql :stripes # joe's override of default
+    end
+  end
 
-      Setting.color(:shorts, :school).should == :black # in sample
-      Setting.color(:shorts, :favorite).should == :white # joe's override
+  context "Complex nested configs" do
+    before :each do
+      subject.reload(
+        path:  File.join(File.dirname(__FILE__)) + '/fixtures',
+        files: ['shipping.yml']
+      )
+    end
 
-      Setting.color(:shorts).should == :stripes # joe's override of default
+    it "should build correct tree with arrays and default values " do
+      expect(subject.shipping_config).to eql "Defaulted"
+      expect(subject.shipping_config(:domestic, :non_shippable_regions).first).to eql "US-AS"
+      expect(subject.shipping_config(:international, :service)).to eql 'Foo'
+      expect(subject.shipping_config(:international, :countries).size).to be > 0
+      expect(subject.shipping_config(:international, :shipping_carrier)).to eql 'Bar'
+      expect(subject.shipping_config(:domestic)['non_shippable_regions'].size).to be > 0
     end
+  end
 
+  context "Ruby code inside yml file" do
+    before :each do
+      subject.reload(
+        path:  File.join(File.dirname(__FILE__)) + '/fixtures',
+        files: ['shipping.yml']
+      )
+    end
+    it "should interpret ruby code and put correct values" do
+      expect(subject.shipping_config).to eql "Defaulted"
+      expect(subject.number).to eql 5
+      expect(subject.stringified).to eql "stringified"
+    end
   end
-end
+end