anyway_config 0.4.0 → 0.5.1.rc1

data/lib/anyway/version.rb

@@ -1,3 +1,5 @@
-module Anyway
-  VERSION = "0.4.0"
-end
+# frozen_string_literal: true
+
+module Anyway # :nodoc:
+  VERSION = "0.5.1.rc1"
+end

data/lib/anyway_config.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "anyway"

data/spec/anyway.yml

@@ -1,2 +1,2 @@
 api:
-  endpoint: 'localhost'
+  endpoint: 'localhost'

data/spec/config_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Anyway::Config do
@@ -5,14 +7,18 @@ describe Anyway::Config do
   let(:test_conf) { Anyway::TestConfig.new }
 
   describe "config with name" do
+    before(:each) do
+      ENV.delete_if { |var| var =~ /^(cool|anyway)_/i }
+    end
+
     specify { expect(CoolConfig.config_name).to eq "cool" }
-    
+
     describe "defaults" do
       specify { expect(CoolConfig.defaults[:port]).to eq 8080 }
       specify { expect(CoolConfig.defaults[:host]).to eq 'localhost' }
     end
 
-    specify do
+    it "generates accessors", :aggregate_failures do
       expect(conf).to respond_to(:meta)
       expect(conf).to respond_to(:data)
       expect(conf).to respond_to(:port)
@@ -21,42 +27,45 @@ describe Anyway::Config do
     end
 
     describe "load from files" do
-      it "should set defauls" do 
+      it "set defaults" do
         expect(conf.port).to eq 8080
       end
 
-      it "should load config from YAML" do
+      it "load config from YAML" do
         expect(conf.host).to eq "test.host"
       end
 
       if Rails.application.respond_to?(:secrets)
-        it "should load config from secrets" do
+        it "load config from secrets" do
           expect(conf.user[:name]).to eq "test"
-          expect(conf.user[:password]).to eq "test"   
         end
       else
-        it "should load config from file if no secrets" do
+        it "load config from file if no secrets" do
           expect(conf.user[:name]).to eq "root"
-          expect(conf.user[:password]).to eq "root"   
+          expect(conf.user[:password]).to eq "root"
         end
       end
     end
 
     describe "load from env" do
-      after(:each) { Anyway.env.clear }
-      it "should work" do
+      it "work" do
         ENV['COOL_PORT'] = '80'
         ENV['COOL_USER__NAME'] = 'john'
-        Anyway.env.reload
+        Anyway.env.clear
         expect(conf.port).to eq 80
         expect(conf.user[:name]).to eq 'john'
       end
+
+      it "handle ENV in YML thru ERB" do
+        ENV['ANYWAY_SECRET_PASSWORD'] = 'my_pass'
+        expect(conf.user[:password]).to eq 'my_pass'
+      end
     end
 
     describe "clear" do
       let(:conf_cleared) { conf.clear }
 
-      specify do
+      it "nullifies values", :aggregate_failures do
         expect(conf_cleared.meta).to be_nil
         expect(conf_cleared.data).to be_nil
         expect(conf_cleared.host).to be_nil
@@ -66,12 +75,11 @@ describe Anyway::Config do
     end
 
     describe "reload" do
-      after(:each) { Anyway.env.clear }
       it do
         expect(conf.port).to eq 8080
         ENV['COOL_PORT'] = '80'
         ENV['COOL_USER__NAME'] = 'john'
-        Anyway.env.reload
+        Anyway.env.clear
         conf.reload
         expect(conf.port).to eq 80
         expect(conf.user[:name]).to eq 'john'
@@ -80,17 +88,20 @@ describe Anyway::Config do
   end
 
   describe "config for name" do
-    after(:each) { Anyway.env.clear }
-    it "should load data by config name" do
+    before(:each) do
+      ENV.delete_if { |var| var =~ /^myapp_/i }
+    end
+
+    it "load data by config name", :aggregate_failures do
       ENV['MYAPP_TEST'] = '1'
       ENV['MYAPP_NAME'] = 'my_app'
-      Anyway.env.reload
+      Anyway.env.clear
       data = Anyway::Config.for(:my_app)
       expect(data[:test]).to eq 1
       expect(data[:name]).to eq 'my_app'
       if Rails.application.respond_to?(:secrets)
-        expect(data[:secret]).to eq 'my_secret' 
+        expect(data[:secret]).to eq 'my_secret'
       end
     end
   end
-end
+end

data/spec/config_spec_norails.rb

@@ -1,43 +1,86 @@
+# frozen_string_literal: true
+
 require 'spec_norails_helper'
 
 describe Anyway::Config do
-  
   let(:conf) { Anyway::TestConfig.new }
 
   describe "config without Rails" do
-    after(:each) { Anyway.env.clear }
+    before(:each) do
+      ENV.delete_if { |var| var =~ /^anyway_/i }
+    end
+
     specify { expect(Anyway::TestConfig.config_name).to eq "anyway" }
 
-    specify do
+    it "has getters", :aggregate_failures do
       expect(conf).to respond_to(:test)
       expect(conf).to respond_to(:api)
+      expect(conf).to respond_to(:log)
+      expect(conf).to respond_to(:log_levels)
     end
 
-    it "should work" do
-      ENV['ANYWAY_CONF'] = File.join(File.dirname(__FILE__),"anyway.yml")
+    it "works", :aggregate_failures do
+      ENV['ANYWAY_CONF'] = File.join(File.dirname(__FILE__), "anyway.yml")
       ENV['ANYWAY_API__KEY'] = 'test1'
       ENV['ANYWAY_TEST'] = 'test'
+      ENV['ANYWAY_LOG__FORMAT__COLOR'] = 't'
+      ENV['ANYWAY_LOG_LEVELS'] = 'debug,warning,info'
 
-      Anyway.env.reload
-      expect(conf.api[:key]).to eq "test1"
-      expect(conf.api[:endpoint]).to eq "localhost"
+      Anyway.env.clear
+      expect(conf.api['key']).to eq "test1"
+      expect(conf.api['endpoint']).to eq "localhost"
       expect(conf.test).to eq "test"
+      expect(conf.log['format']['color']).to eq true
+      expect(conf.log_levels).to eq(%w[debug warning info])
     end
 
-    it "should reload config" do
-      expect(conf.api[:key]).to eq ""
-      expect(conf.api[:endpoint]).to be_nil
+    it "reloads config", :aggregate_failures do
+      ENV['ANYWAY_CONF'] = File.join(File.dirname(__FILE__), "anyway.yml")
+
+      expect(conf.api['key']).to eq ""
+      expect(conf.api['endpoint']).to eq 'localhost'
       expect(conf.test).to be_nil
+      expect(conf.log['format']['color']).to eq false
 
-      ENV['ANYWAY_CONF'] = File.join(File.dirname(__FILE__),"anyway.yml")
       ENV['ANYWAY_API__KEY'] = 'test1'
+      ENV['ANYWAY_API__SSL'] = 'yes'
       ENV['ANYWAY_TEST'] = 'test'
-      Anyway.env.reload
+      ENV['ANYWAY_LOG__FORMAT__COLOR'] = 't'
+      Anyway.env.clear
 
       conf.reload
-      expect(conf.api[:key]).to eq "test1"
-      expect(conf.api[:endpoint]).to eq "localhost"
+      expect(conf.api['key']).to eq "test1"
+      expect(conf.api['ssl']).to eq true
+      expect(conf.api['endpoint']).to eq "localhost"
       expect(conf.test).to eq "test"
+      expect(conf.log['format']['color']).to eq true
+    end
+
+    context "config without keys" do
+      let(:empty_config_class) { Class.new(Anyway::Config) }
+
+      let(:conf) { empty_config_class.new }
+
+      specify { expect(conf.config_name).to be_nil }
+    end
+
+    context "loading from default path" do
+      let(:conf) { CoolConfig.new }
+
+      before(:each) do
+        ENV.delete_if { |var| var =~ /^cool_/i }
+      end
+
+      it "loads from ./config", :aggregate_failures do
+        expect(conf.user).to eq("name" => "root", "password" => "root")
+        expect(conf.host).to eq "test.host"
+        expect(conf.port).to eq 9292
+      end
+
+      it "handle ENV in YML thru ERB" do
+        ENV["ANYWAY_COOL_PORT"] = "1957"
+        expect(conf.port).to eq 1957
+      end
     end
   end
-end
+end

data/spec/dummy/config.ru

@@ -1,4 +0,0 @@
-# This file is used by Rack-based servers to start the application.
-
-require ::File.expand_path('../config/environment',  __FILE__)
-run Dummy::Application

data/spec/dummy/config/application.rb

@@ -1,22 +1,13 @@
 require File.expand_path('../boot', __FILE__)
 
-require 'rails/all'
+require "rails"
 
 Bundler.require(*Rails.groups)
 
 module Dummy
   class Application < Rails::Application
-    # Settings in config/environments/* take precedence over those specified here.
-    # Application configuration should go into files in config/initializers
-    # -- all .rb files in that directory are automatically loaded.
-
-    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
-    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
-    # config.time_zone = 'Central Time (US & Canada)'
-
-    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
-    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
-    # config.i18n.default_locale = :de
+    config.logger = Logger.new('/dev/null')
+    config.eager_load = false
   end
 end
 

data/spec/dummy/config/cool.yml

@@ -2,4 +2,4 @@ test:
   host: "test.host"
   user:
     name: "root"
-    password: "root"
+    password: <%= ENV['ANYWAY_SECRET_PASSWORD'] || "root" %>

data/spec/dummy/config/environments/test.rb

@@ -1,39 +1,2 @@
 Dummy::Application.configure do
-  # Settings specified here will take precedence over those in config/application.rb.
-
-  # The test environment is used exclusively to run your application's
-  # test suite. You never need to work with it otherwise. Remember that
-  # your test database is "scratch space" for the test suite and is wiped
-  # and recreated between test runs. Don't rely on the data there!
-  config.cache_classes = true
-
-  # Do not eager load code on boot. This avoids loading your whole application
-  # just for the purpose of running a single test. If you are using a tool that
-  # preloads Rails for running tests, you may have to set it to true.
-  config.eager_load = false
-
-  # Configure static asset server for tests with Cache-Control for performance.
-  config.serve_static_files  = true
-  config.static_cache_control = 'public, max-age=3600'
-
-  # Show full error reports and disable caching.
-  config.consider_all_requests_local       = true
-  config.action_controller.perform_caching = false
-
-  # Raise exceptions instead of rendering exception templates.
-  config.action_dispatch.show_exceptions = false
-
-  # Disable request forgery protection in test environment.
-  config.action_controller.allow_forgery_protection = false
-
-  # Tell Action Mailer not to deliver emails to the real world.
-  # The :test delivery method accumulates sent emails in the
-  # ActionMailer::Base.deliveries array.
-  config.action_mailer.delivery_method = :test
-
-  # Print deprecation notices to the stderr.
-  config.active_support.deprecation = :stderr
-
-  # Raises error for missing translations
-  # config.action_view.raise_on_missing_translations = true
 end

data/spec/dummy/config/routes.rb

@@ -1,56 +1,2 @@
 Dummy::Application.routes.draw do
-  # The priority is based upon order of creation: first created -> highest priority.
-  # See how all your routes lay out with "rake routes".
-
-  # You can have the root of your site routed with "root"
-  # root 'welcome#index'
-
-  # Example of regular route:
-  #   get 'products/:id' => 'catalog#view'
-
-  # Example of named route that can be invoked with purchase_url(id: product.id)
-  #   get 'products/:id/purchase' => 'catalog#purchase', as: :purchase
-
-  # Example resource route (maps HTTP verbs to controller actions automatically):
-  #   resources :products
-
-  # Example resource route with options:
-  #   resources :products do
-  #     member do
-  #       get 'short'
-  #       post 'toggle'
-  #     end
-  #
-  #     collection do
-  #       get 'sold'
-  #     end
-  #   end
-
-  # Example resource route with sub-resources:
-  #   resources :products do
-  #     resources :comments, :sales
-  #     resource :seller
-  #   end
-
-  # Example resource route with more complex sub-resources:
-  #   resources :products do
-  #     resources :comments
-  #     resources :sales do
-  #       get 'recent', on: :collection
-  #     end
-  #   end
-
-  # Example resource route with concerns:
-  #   concern :toggleable do
-  #     post 'toggle'
-  #   end
-  #   resources :posts, concerns: :toggleable
-  #   resources :photos, concerns: :toggleable
-
-  # Example resource route within a namespace:
-  #   namespace :admin do
-  #     # Directs /admin/products/* to Admin::ProductsController
-  #     # (app/controllers/admin/products_controller.rb)
-  #     resources :products
-  #   end
 end

data/spec/dummy/config/secrets.yml

@@ -18,7 +18,6 @@ test:
   cool:
     user:
       name: test
-      password: test
     bullshit: 'mooo'
   my_app:
     name: 'app'

data/spec/env_spec.rb

@@ -1,32 +1,36 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Anyway::Env do
-  let(:env) { Anyway.env.reload }
+  let(:env) { Anyway.env }
 
-  it "should load simple key/values by module" do
+  it "loads simple key/values by module", :aggregate_failures do
     ENV['TESTO_KEY'] = 'a'
     ENV['MYTEST_KEY'] = 'b'
-    expect(env.testo[:key]).to eq 'a'
-    expect(env.my_test['key']).to eq 'b'
+    expect(env.fetch('testo')['key']).to eq 'a'
+    expect(env.fetch('my_test')['key']).to eq 'b'
   end
 
-  it "should load hash values" do
+  it "loads hash values", :aggregate_failures do
     ENV['TESTO_DATA__ID'] = '1'
     ENV['TESTO_DATA__META__NAME'] = 'meta'
     ENV['TESTO_DATA__META__VAL'] = 'true'
-    expect(env.testo[:data][:id]).to eq 1
-    expect(env.testo[:data][:meta][:name]).to eq 'meta'
-    expect(env.testo[:data][:meta][:val]).to be_truthy
+    testo_config = env.fetch('testo')
+    expect(testo_config['data']['id']).to eq 1
+    expect(testo_config['data']['meta']['name']).to eq 'meta'
+    expect(testo_config['data']['meta']['val']).to be_truthy
   end
 
-  it "should load array values" do
+  it "loads array values", :aggregate_failures do
     ENV['TESTO_DATA__IDS'] = '1,2, 3'
     ENV['TESTO_DATA__META__NAMES'] = 'meta, kotleta'
     ENV['TESTO_DATA__META__SIZE'] = '2'
     ENV['TESTO_DATA__TEXT'] = '"C\'mon, everybody"'
-    expect(env.testo[:data][:ids]).to include(1,2,3)
-    expect(env.testo[:data][:meta][:names]).to include('meta','kotleta')
-    expect(env.testo[:data][:meta][:size]).to eq 2
-    expect(env.testo[:data][:text]).to eq "C'mon, everybody"
+    testo_config = env.fetch('testo')
+    expect(testo_config['data']['ids']).to include(1, 2, 3)
+    expect(testo_config['data']['meta']['names']).to include('meta', 'kotleta')
+    expect(testo_config['data']['meta']['size']).to eq 2
+    expect(testo_config['data']['text']).to eq "C'mon, everybody"
   end
-end
+end

data/spec/ext/deep_dup_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Anyway::Ext::DeepDup do
+  using Anyway::Ext::DeepDup
+
+  it "duplicates nested arrays and hashes", :aggregate_failures do
+    source = {
+      a: 1,
+      b: 'hello',
+      c: {
+        id: 1,
+        list: [1, 2, { name: 'John' }]
+      },
+      d: [{ id: 1 }, { id: 2 }]
+    }
+
+    dup = source.deep_dup
+
+    expect(dup[:a]).to eq 1
+    expect(dup[:b]).to eq 'hello'
+    expect(dup[:c]).to eq(
+      id: 1,
+      list: [1, 2, { name: 'John' }]
+    )
+    expect(dup[:d]).to eq(
+      [{ id: 1 }, { id: 2 }]
+    )
+
+    expect(dup[:c]).not_to be_equal(source[:c])
+    expect(dup[:c][:list]).not_to be_equal(source[:c][:list])
+    expect(dup[:c][:list].last).not_to be_equal(source[:c][:list].last)
+
+    expect(dup[:d].first).not_to be_equal(source[:d].first)
+    expect(dup[:d].last).not_to be_equal(source[:d].last)
+  end
+end