sinclair 2.0.0 → 2.1.0

data/lib/sinclair.rb

@@ -85,6 +85,7 @@ class Sinclair
   autoload :VERSION,           'sinclair/version'
   autoload :Caster,            'sinclair/caster'
   autoload :ClassMethods,      'sinclair/class_methods'
+  autoload :ChainSettable,     'sinclair/chain_settable'
   autoload :Config,            'sinclair/config'
   autoload :ConfigBuilder,     'sinclair/config_builder'
   autoload :ConfigClass,       'sinclair/config_class'
@@ -100,6 +101,7 @@ class Sinclair
   autoload :MethodDefinitions, 'sinclair/method_definitions'
   autoload :Model,             'sinclair/model'
   autoload :Options,           'sinclair/options'
+  autoload :Settable,          'sinclair/settable'
 
   include OptionsParser
   extend ClassMethods

data/spec/integration/yard/sinclair/env_settable_spec.rb

@@ -4,42 +4,23 @@ require 'spec_helper'
 
 describe Sinclair::EnvSettable do
   describe '#yard' do
-    subject(:settable) { Class.new(MyAppClient) }
+    subject(:settable) { MyAppClient }
 
     before do
       ENV['MY_APP_USERNAME'] = 'my_login'
+      ENV['MY_APP_PORT'] = '8080'
     end
 
     after do
       ENV.delete('MY_APP_USERNAME')
+      ENV.delete('MY_APP_PORT')
     end
 
-    it 'retrieves username from env' do
+    it 'retrieves data from env' do
       expect(settable.username).to eq('my_login')
-    end
-
-    it 'retrieves password from env' do
       expect(settable.password).to be_nil
-    end
-
-    context 'when defining defaults' do
-      it 'returns default value' do
-        expect(settable.host).to eq('my-host.com')
-      end
-
-      context 'when setting the env variable' do
-        before do
-          ENV['MY_APP_HOST'] = 'other-host.com'
-        end
-
-        after do
-          ENV.delete('MY_APP_HOST')
-        end
-
-        it 'retrieves host from env' do
-          expect(settable.host).to eq('other-host.com')
-        end
-      end
+      expect(settable.host).to eq('my-host.com')
+      expect(settable.port).to eq(8080)
     end
   end
 end

data/spec/integration/yard/sinclair/settable/caster_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Settable::Caster do
+  describe '#yard' do
+    describe 'altering base caster' do
+      subject(:settable) { MathEnvSettings }
+
+      before do
+        ENV['MATH_VALUE'] = '80'
+      end
+
+      after do
+        ENV.delete('MATH_VALUE')
+      end
+
+      it 'retrieves data from env' do
+        expect(settable.value).to eq(6400.0)
+      end
+    end
+
+    describe 'creating a new caster' do
+      subject(:settable) { JsonEnvSettings }
+
+      let(:hash) { { key: 'value' } }
+
+      before do
+        ENV['JSON_CONFIG'] = hash.to_json
+      end
+
+      after do
+        ENV.delete('JSON_CONFIG')
+      end
+
+      it 'retrieves data from env' do
+        expect(settable.config).to eq(hash.stringify_keys)
+      end
+    end
+  end
+end

data/spec/integration/yard/sinclair/settable/class_methods_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Settable::ClassMethods do
+  describe 'yard #read_with' do
+    it 'reads the settings from the file' do
+      expect(YamlFileSettings.timeout).to eq(10)
+    end
+  end
+end

data/spec/integration/yard/sinclair/settable_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Settable do
+  describe '#yard' do
+    subject(:settable) { HashAppClient }
+
+    before do
+      HashAppClient::HASH[:username] = 'my_login'
+      HashAppClient::HASH[:port] = '8080'
+    end
+
+    after do
+      HashAppClient::HASH.delete(:username)
+      HashAppClient::HASH.delete(:port)
+    end
+
+    it 'retrieves data from env' do
+      expect(settable.username).to eq('my_login')
+      expect(settable.password).to be_nil
+      expect(settable.host).to eq('my-host.com')
+      expect(settable.port).to eq(8080)
+    end
+  end
+end

data/spec/lib/sinclair/chain_settable_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::ChainSettable do
+  subject(:settable) do
+    options = options_hash
+
+    Class.new do
+      extend Sinclair::ChainSettable
+
+      source :app_client, Class.new(NonDefaultAppClient)
+      source :my_app_client, Class.new(MyAppClient)
+
+      setting_with_options :username, :password, :host, :port, **options
+    end
+  end
+
+  let(:options_hash) { {} }
+  let(:username)     { 'my_login' }
+  let(:password)     { Random.rand(10_000).to_s }
+
+  context 'when the first setting finds the data' do
+    let(:username_key) { 'USERNAME' }
+    let(:password_key) { 'PASSWORD' }
+    let(:host_key)     { 'HOST' }
+    let(:port_key)     { 'PORT' }
+
+    it_behaves_like 'settings reading'
+  end
+
+  context 'when the second setting finds the data' do
+    let(:username_key) { 'MY_APP_USERNAME' }
+    let(:password_key) { 'MY_APP_PASSWORD' }
+    let(:host_key)     { 'MY_APP_HOST' }
+    let(:port_key)     { 'MY_APP_PORT' }
+
+    it_behaves_like 'settings reading'
+  end
+
+  context 'when both have a value' do
+    let(:first_username)  { 'first_username' }
+    let(:second_username) { 'second_username' }
+
+    before do
+      ENV['USERNAME'] = first_username
+      ENV['MY_APP_USERNAME'] = second_username
+    end
+
+    after do
+      ENV.delete('USERNAME')
+      ENV.delete('MY_APP_USERNAME')
+    end
+
+    it 'returns the first value' do
+      expect(settable.username).to eq(first_username)
+    end
+
+    context 'when passing a different source as options' do
+      let(:options_hash) { { sources: %i[my_app_client app_client] } }
+
+      it 'returns the second value' do
+        expect(settable.username).to eq(second_username)
+      end
+    end
+  end
+
+  context 'when none has value' do
+    let(:default)      { 'some_default_username' }
+    let(:options_hash) { { default: default } }
+
+    it 'returns the first value' do
+      expect(settable.username).to eq(default)
+    end
+  end
+end

data/spec/lib/sinclair/class_methods_spec.rb

@@ -10,7 +10,7 @@ describe Sinclair::ClassMethods do
   let(:dummy_class)   { Class.new }
   let(:builder_class) { Sinclair }
 
-  describe '#build' do
+  describe '.build' do
     let(:block) do
       method_name = :some_method
       value = 1
@@ -21,13 +21,13 @@ describe Sinclair::ClassMethods do
     end
 
     it 'executes the block and builds' do
-      expect { builder_class.build(dummy_class, options, &block) }
+      expect { builder_class.build(dummy_class, **options, &block) }
         .to add_method(:some_method).to(dummy_class)
     end
 
     context 'when the method is built and called' do
       before do
-        builder_class.build(dummy_class, options, &block)
+        builder_class.build(dummy_class, **options, &block)
       end
 
       it 'returns the value' do
@@ -46,9 +46,29 @@ describe Sinclair::ClassMethods do
       end
 
       it 'executes the block and builds' do
-        expect { builder_class.build(dummy_class, options) }
+        expect { builder_class.build(dummy_class, **options) }
           .to add_method(:some_method).to(dummy_class)
       end
     end
+
+    context 'when a block is given and initialization contains more arguments' do
+      let(:builder_class) { ComplexBuilder }
+      let(:value)         { Random.rand(10..30) }
+      let(:power)         { Random.rand(3..5) }
+      let(:result)        { value**power }
+
+      it 'executes the block and builds' do
+        expect { builder_class.build(dummy_class, value, power, &:add_default) }
+          .to add_method(:result).to(dummy_class)
+      end
+
+      context 'when the method is called' do
+        before { builder_class.build(dummy_class, value, power, &:add_default) }
+
+        it 'returns the evaluated value' do
+          expect(instance.result).to eq(result)
+        end
+      end
+    end
   end
 end

data/spec/lib/sinclair/env_settable_spec.rb

@@ -11,8 +11,9 @@ describe Sinclair::EnvSettable do
   let(:username_key) { 'USERNAME' }
   let(:password_key) { 'PASSWORD' }
   let(:host_key)     { 'HOST' }
+  let(:port_key)     { 'PORT' }
 
-  it_behaves_like 'settings reading from env'
+  it_behaves_like 'settings reading'
 
   context 'when defining a prefix' do
     subject(:settable) { Class.new(MyAppClient) }
@@ -20,7 +21,8 @@ describe Sinclair::EnvSettable do
     let(:username_key) { 'MY_APP_USERNAME' }
     let(:password_key) { 'MY_APP_PASSWORD' }
     let(:host_key)     { 'MY_APP_HOST' }
+    let(:port_key)     { 'MY_APP_PORT' }
 
-    it_behaves_like 'settings reading from env'
+    it_behaves_like 'settings reading'
   end
 end

data/spec/lib/sinclair/settable/builder_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Settable::Builder do
+  subject(:settable) do
+    setting_prefix = prefix
+
+    Class.new do
+      extend Sinclair::EnvSettable
+
+      settings_prefix setting_prefix
+    end
+  end
+
+  let(:username)   { 'my_login' }
+  let(:password)   { Random.rand(10_000).to_s }
+  let(:settings)   { %i[username password] }
+  let(:options)    { { prefix: prefix } }
+
+  let(:builder) do
+    described_class.new(settable, *settings, **options)
+  end
+
+  before { builder.build }
+
+  context 'when not using prefix' do
+    let(:prefix) { nil }
+
+    let(:username_key) { 'USERNAME' }
+    let(:password_key) { 'PASSWORD' }
+    let(:host_key)     { 'HOST' }
+    let(:port_key)     { 'PORT' }
+
+    it_behaves_like 'settings reading'
+  end
+
+  context 'when defining a prefix' do
+    let(:prefix)       { 'MY_APP' }
+    let(:username_key) { 'MY_APP_USERNAME' }
+    let(:password_key) { 'MY_APP_PASSWORD' }
+    let(:host_key)     { 'MY_APP_HOST' }
+    let(:port_key)     { 'MY_APP_PORT' }
+
+    it_behaves_like 'settings reading'
+  end
+end

data/spec/lib/sinclair/settable_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Settable do
+  context 'when reading from env' do
+    subject(:settable) { Class.new(AppClient) }
+
+    let(:username) { 'my_login' }
+    let(:password) { Random.rand(10_000).to_s }
+
+    let(:username_key) { 'USERNAME' }
+    let(:password_key) { 'PASSWORD' }
+    let(:host_key)     { 'HOST' }
+    let(:port_key)     { 'PORT' }
+
+    it_behaves_like 'settings reading'
+
+    context 'when defining a prefix' do
+      subject(:settable) { Class.new(MyAppClient) }
+
+      let(:username_key) { 'MY_APP_USERNAME' }
+      let(:password_key) { 'MY_APP_PASSWORD' }
+      let(:host_key)     { 'MY_APP_HOST' }
+      let(:port_key)     { 'MY_APP_PORT' }
+
+      it_behaves_like 'settings reading'
+    end
+  end
+
+  context 'when reading from a hash constant' do
+    subject(:settable) { Class.new(HashAppClient) }
+
+    let(:username) { 'my_login' }
+    let(:password) { Random.rand(10_000).to_s }
+
+    let(:username_key) { :username }
+    let(:password_key) { :password }
+    let(:host_key)     { :host }
+    let(:port_key)     { :port }
+
+    it_behaves_like 'settings reading' do
+      let(:env_hash) { HashAppClient::HASH }
+    end
+  end
+end

data/spec/support/files/config.yml

@@ -0,0 +1 @@
+timeout: 10

data/spec/support/models/app_client.rb

@@ -4,4 +4,5 @@ class AppClient
   extend Sinclair::EnvSettable
 
   with_settings :username, :password, host: 'my-host.com'
+  setting_with_options :port, type: :integer
 end

data/spec/support/models/complex_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class ComplexBuilder < Sinclair
+  def initialize(klass, value, power)
+    @value = value
+    @power = power
+
+    super(klass)
+  end
+
+  def add_default
+    val = @value
+    pow = @power
+
+    add_method(:result) { val**pow }
+  end
+end

data/spec/support/models/hash_app_client.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require './spec/support/models/hash_settable'
+
+class HashAppClient
+  extend HashSettable
+
+  # rubocop:disable Style/MutableConstant
+  HASH = {}
+  # rubocop:enable Style/MutableConstant
+
+  with_settings :username, :password, host: 'my-host.com'
+  setting_with_options :port, type: :integer
+end

data/spec/support/models/hash_settable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module HashSettable
+  extend Sinclair::Settable::ClassMethods
+  include Sinclair::Settable
+
+  read_with do |key|
+    self::HASH[key]
+  end
+end

data/spec/support/models/json_env_settings.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JsonEnvSettable
+  include Sinclair::EnvSettable
+  extend Sinclair::Settable::ClassMethods
+
+  class Caster < Sinclair::Settable::Caster
+    cast_with(:json) { |value| JSON.parse(value) }
+  end
+end
+
+class JsonEnvSettings
+  extend JsonEnvSettable
+
+  settings_prefix 'JSON'
+
+  setting_with_options :config, type: :json
+end

data/spec/support/models/math_env_settings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Sinclair
+  module Settable
+    class Caster
+      cast_with(:squared) { |value| value.to_f**2 }
+    end
+  end
+end
+
+class MathEnvSettings
+  extend Sinclair::EnvSettable
+
+  settings_prefix 'MATH'
+
+  setting_with_options :value, type: :squared
+end

data/spec/support/models/my_app_client.rb

@@ -6,4 +6,5 @@ class MyAppClient
   settings_prefix 'MY_APP'
 
   with_settings :username, :password, host: 'my-host.com'
+  setting_with_options :port, type: :integer
 end

data/spec/support/models/non_default_app_client.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class NonDefaultAppClient
+  extend Sinclair::EnvSettable
+
+  with_settings :username, :password, :host
+  setting_with_options :port, type: :integer
+end

data/spec/support/models/yaml_file_settings.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module YamlFileSettable
+  include Sinclair::Settable
+  extend Sinclair::Settable::ClassMethods
+
+  read_with do |key|
+    loaded_yaml[key.to_s]
+  end
+
+  def loaded_yaml
+    YAML.load_file(setting_file)
+  end
+
+  def setting_file(file_path = @setting_file)
+    @setting_file = file_path
+  end
+end
+
+class YamlFileSettings
+  extend YamlFileSettable
+
+  setting_file './spec/support/files/config.yml'
+
+  setting_with_options :timeout, default: 30
+end

data/spec/support/shared_examples/settable.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+shared_examples 'settings reading' do
+  let(:env_hash) { ENV }
+
+  context 'when the key is not set' do
+    it 'retrieves username from env' do
+      expect(settable.username).to be_nil
+    end
+
+    it 'retrieves password from env' do
+      expect(settable.password).to be_nil
+    end
+  end
+
+  context 'when the key is set' do
+    before do
+      env_hash[username_key] = username
+      env_hash[password_key] = password
+    end
+
+    after do
+      env_hash.delete(username_key)
+      env_hash.delete(password_key)
+    end
+
+    it 'retrieves username from env' do
+      expect(settable.username).to eq(username)
+    end
+
+    it 'retrieves password from env' do
+      expect(settable.password).to eq(password)
+    end
+  end
+
+  context 'when defining defaults' do
+    let(:settings)   { %i[host] }
+    let(:options)    { { prefix: prefix, default: 'my-host.com' } }
+
+    it 'returns default value' do
+      expect(settable.host).to eq('my-host.com')
+    end
+
+    context 'when setting the env variable' do
+      let(:other_host) { 'other-host.com' }
+
+      before do
+        env_hash[host_key] = other_host
+      end
+
+      after do
+        env_hash.delete(host_key)
+      end
+
+      it 'retrieves host from env' do
+        expect(settable.host).to eq(other_host)
+      end
+    end
+  end
+
+  context 'when defining a type' do
+    let(:settings) { %i[port] }
+    let(:options)  { { prefix: prefix, type: :integer } }
+    let(:port)     { Random.rand(10..100) }
+
+    context 'when the key is not set' do
+      it 'retrieves port and cast to string' do
+        expect(settable.port).to be_nil
+      end
+    end
+
+    context 'when the key is set' do
+      before do
+        env_hash[port_key] = port.to_s
+      end
+
+      after do
+        env_hash.delete(port_key)
+      end
+
+      it 'retrieves port and cast to string' do
+        expect(settable.port).to eq(port)
+      end
+    end
+  end
+end