rdm 0.4.17 → 0.4.18

data/lib/rdm/yml_config/config_manager.rb

@@ -1,39 +0,0 @@
-require 'yaml'
-
-class Rdm::ConfigManager
-  class << self
-    def load_config(envs:, path_to_config:)
-      new_config = Rdm::ConfigCaster.new(envs).cast(YAML.load(File.read(path_to_config)))
-      validate_params!(new_config, envs)
-      
-      instance.config.merge! new_config
-    end
-
-    def reset!
-      instance.config.clear
-    end
-
-    def method_missing(meth, *args, &block)
-      instance.send(meth)
-    end
-
-    def instance
-      @instance ||= new
-    end
-
-    private
-
-    def validate_params!(config, envs)
-      Rdm::ConfigValidator.new(envs).validate!(config)
-    end
-  end
-
-  def method_missing(meth)
-    config.keys.include?(meth) ? Rdm::Utils::Ostruct.to_recursive_ostruct(config).send(meth) : 
-                                 (raise ArgumentError, ":#{meth} configuration was not defined for current package. Add `import '#{meth}'` to your Package.rb file")
-  end
-
-  def config
-    @config ||= {}
-  end
-end

data/lib/rdm/yml_config/config_validator.rb

@@ -1,51 +0,0 @@
-require 'attr_validator'
-
-class Rdm::ConfigValidator
-  def initialize(env_config)
-    @env_config = env_config
-  end
-
-  def validate!(hash_config)
-    dto = OpenStruct.new(hash_config)
-
-    if @env_config.is_hash?
-      @env_config.children.each do |subconfig|
-        self.class.new(subconfig).validate!(dto.send(@env_config.name).to_h)
-      end
-    elsif @env_config.is_array?
-      dto.send(@env_config.name).each do |el|
-        array_dto = OpenStruct.new(@env_config.name => el)
-        validator(@env_config.name, @env_config.children.first.validates.to_hash).validate!(array_dto)
-      end
-    else
-      validator(@env_config.name, @env_config.validates.to_hash).validate!(dto)
-    end
-
-    dto
-  rescue AttrValidator::Errors::ValidationError => e
-    raise Rdm::Errors::InvalidConfig, e.message
-  end
-
-  private
-
-  def validator(name, env_config)
-    return @validator if @validator
-
-    validator_class = Class.new
-    validator_class.include(AttrValidator::Validator)
-
-    validator_class.class_eval( to_attr_validator_string(name, env_config) )
-
-    @validator = validator_class.new
-  end
-
-  def to_attr_validator_string(name, validates)
-    validates_string = []
-
-    validates.each do |key, value|
-      validates_string.push "validates :#{name}, #{key}: #{value}"
-    end
-
-    validates_string.join("\n")
-  end
-end

data/lib/rdm/yml_config/env_config.rb

@@ -1,46 +0,0 @@
-class Rdm::EnvConfig
-  module Types
-    STRING  = :string
-    ARRAY   = :array
-    HASH    = :hash
-    SYMBOL  = :symbol
-    INTEGER = :integer
-
-    ALL = [STRING, ARRAY, HASH, SYMBOL, INTEGER]
-  end
-
-  attr_reader :name, :type, :optional, :default, :validates
-  attr_accessor :children
-
-  def initialize(name:, type:, optional: false, default: nil, validates: nil, children: nil)
-    @name      = name
-    @type      = Types::ALL.include?(type) ? type: (raise ArgumentError, "Invalid env type")
-    @optional  = !!optional
-    @validates = validates || Rdm::ValidateConfig.new
-    @children  = (children || []).select {|e| e.is_a?(Rdm::EnvConfig)}
-    @default   = default
-  end
-
-  def to_hash
-    hash = {
-      name:      @name,
-      type:      @type,
-      optional:  @optional,
-      default:   @default,
-    }.delete_if { |_, v| v.nil? }
-
-    hash[:children]  = @children.map(&:to_hash) if @children.any?
-    hash[:validates] = @validates.to_hash   if @validates.to_hash.any?
-
-    hash
-  end
-
-  def is_array?
-    @type == Types::ARRAY
-  end
-
-  def is_hash?
-    @type == Types::HASH
-  end
-end
-

data/lib/rdm/yml_config/env_config_dsl.rb

@@ -1,92 +0,0 @@
-class Rdm::EnvConfigDSL
-  attr_reader :data
-
-  module Types
-    STRING  = :string
-    ARRAY   = :array
-    HASH    = :hash
-    SYMBOL  = :symbol
-    INTEGER = :integer
-
-    ALL = [STRING, ARRAY, HASH, SYMBOL, INTEGER]
-  end
-
-  def initialize
-    @data = []
-  end
-
-  def string(name, opts = {}, &block)
-    validations = Rdm::ValidateConfig.new
-    validations.instance_exec(&block) if block_given?
-
-    @data.push(
-      Rdm::EnvConfig.new(
-        name:        name,
-        type:        Types::STRING,
-        optional:    opts[:optional],
-        default:     opts[:default],
-        validates:   validations
-      )
-    )
-  end
-
-  def symbol(name, opts = {}, &block)
-    validations = Rdm::ValidateConfig.new
-    validations.instance_exec(&block) if block_given?
-    
-    @data.push(
-      Rdm::EnvConfig.new(
-        name:        name,
-        type:        Types::SYMBOL,
-        optional:    opts[:optional],
-        default:     opts[:default],
-        validates:   validations
-      )
-    )
-  end
-
-  def integer(name, opts = {}, &block)
-    validations = Rdm::ValidateConfig.new
-    validations.instance_exec(&block) if block_given?
-
-    @data.push(
-      Rdm::EnvConfig.new(
-        name:        name,
-        type:        Types::INTEGER,
-        optional:    opts[:optional],
-        default:     opts[:default],
-        validates:   validations
-      )
-    )
-  end
-
-  def array(name, opts = {}, &block)
-    array_values = self.class.new
-    array_values.send(opts.fetch(:each), nil, {}, &block)
-
-    @data.push(
-      Rdm::EnvConfig.new(
-        name:        name,
-        type:        Types::ARRAY,
-        optional:    opts[:optional],
-        default:     opts[:default],
-        children:    array_values.data
-      )
-    )
-  end
-
-  def hash(name, opts = {}, &block)
-    hash_values = self.class.new
-    hash_values.instance_exec(&block)
-
-    @data.push(
-      Rdm::EnvConfig.new(
-        name:        name,
-        type:        Types::HASH,
-        optional:    opts[:optional],
-        default:     opts[:default],
-        children:    hash_values.data
-      )
-    )
-  end
-end

data/lib/rdm/yml_config/validate_config.rb

@@ -1,13 +0,0 @@
-class Rdm::ValidateConfig
-  def initialize
-    @data = {}
-  end
-
-  def method_missing(method, *args, &block)
-    @data[method] = args.first
-  end
-
-  def to_hash
-    @data
-  end
-end

data/spec/fixtures/app.yml

@@ -1,17 +0,0 @@
-core:
-  some_key:
-    - value1
-    - value2
-    - value3
-    
-web:
-  some_key:
-    - value1
-    - value2
-    - value3
-
-factory:
-  some_key:
-    - value1
-    - value2
-    - value3

data/spec/rdm/yml_config/config_caster_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe Rdm::ConfigCaster do
-  subject { described_class.new(env) }
-
-  describe "#to_hcast_string" do
-    context 'for string env' do
-      let(:env) {
-        Rdm::EnvConfig.new(
-          name:        :string_env,
-          type:        :string
-        )
-      }
-
-      it 'generates proper string' do
-        expect(
-          subject.to_hcast_string(env)
-        ).to eq("string :string_env, optional: false")
-      end
-    end
-
-    context 'for array env' do
-      let(:env) {
-        Rdm::EnvConfig.new(
-          name:        :array_env,
-          type:        :array,
-          children: [
-            Rdm::EnvConfig.new(
-              name:        :string_env,
-              type:        :string
-            )
-          ]
-        )
-      }
-
-      it 'generates proper string' do
-        expect(
-          subject.to_hcast_string(env)
-        ).to eq("array :array_env, optional: false, each: :string")
-      end
-    end
-
-    context 'for hash env' do
-      let(:env) {
-        Rdm::EnvConfig.new(
-          name:        :hash_env,
-          type:        :hash,
-          children: [
-            Rdm::EnvConfig.new(
-              name:        :string_env,
-              type:        :string
-            )
-          ]
-        )
-      }
-
-      it 'generates proper string' do
-        expect(
-          subject.to_hcast_string(env)
-        ).to eq("hash :hash_env, optional: false do \n  string :string_env, optional: false \nend")
-      end
-    end
-  end
-end

data/spec/rdm/yml_config/config_manager_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Rdm::ConfigManager do
-  describe '#load_config' do
-    
-  end
-end

data/spec/rdm/yml_config/config_validator_spec.rb

@@ -1,190 +0,0 @@
-require 'spec_helper'
-
-describe Rdm::ConfigValidator do
-
-  let(:hash_config) {
-    {
-      example_config: {
-        example_array_config:   ['hello', 'world'],
-        example_symbol_config:  :values,
-        example_integer_config: 25,
-        example_email_config:   'info@rdm.com'
-      }
-    }
-  }
-
-  let(:array_config) {
-    Rdm::EnvConfig.new(
-      name:      'example_array_config',
-      type:      :array,
-      validates: nil,
-      children: [
-        Rdm::EnvConfig.new(
-          name: nil,
-          type: :string,
-          validates: {
-            length: {
-              equal_to: 5
-            }
-          }
-        )
-      ]
-    )
-  }
-  let(:symbol_config) {
-    Rdm::EnvConfig.new(
-      name: 'example_symbol_config',
-      type: :symbol,
-      validates: {
-        inclusion: {
-          in: [:example, :symbol, :config, :values]
-        }
-      }
-    )
-  }
-  let(:integer_config) {
-    Rdm::EnvConfig.new(
-      name: 'example_integer_config',
-      type: :integer,
-      validates: {
-        numericality: {
-          greater_than_or_equal_to: 5,
-          less_than: 50
-        }
-      }
-    )
-  }
-  let(:email_config) {
-    Rdm::EnvConfig.new(
-      name:     'example_email_config',
-      type:     :string,
-      optional: true,
-      validates: {
-        email: true,
-        presence: true
-      }
-    )
-  }
-
-  let(:env_config) {
-    Rdm::EnvConfig.new(
-      name:      'example_config',
-      type:      :hash,
-      optional:  true,
-      default:   nil,
-      validates: nil,
-      children: [
-        array_config,
-        symbol_config,
-        integer_config,
-        email_config
-      ]
-    )
-  }
-
-  describe '#validate' do
-    context 'for symbol config' do
-      it 'not raises error for valid params' do
-        expect {
-          described_class.new(symbol_config).validate!({example_symbol_config: :example})
-        }.not_to raise_error
-      end
-
-      it 'raises ArgumentError if invalid params' do
-        expect {
-          described_class.new(symbol_config).validate!({example_symbol_config: :unpermitted_parameter})
-        }.to raise_error Rdm::Errors::InvalidConfig
-      end
-
-      it 'returns OpenStruct' do
-        expect(
-          described_class.new(symbol_config).validate!({example_symbol_config: :example})
-        ).to eq(OpenStruct.new({example_symbol_config: :example}))
-      end
-    end
-
-    context 'for email config' do
-      it 'not raises error for valid params' do
-        expect {
-          described_class.new(email_config).validate!({example_email_config: 'hello@world.ru'})
-        }.not_to raise_error
-      end
-
-      it 'raises ArgumentError if invalid params' do
-        expect {
-          described_class.new(email_config).validate!({example_email_config: 'helloworld'})
-        }.to raise_error Rdm::Errors::InvalidConfig
-      end
-
-      it 'returns OpenStruct' do
-        expect(
-          described_class.new(email_config).validate!({example_email_config: 'hello@world.ru'})
-        ).to eq(OpenStruct.new({example_email_config: 'hello@world.ru'}))
-      end
-    end
-
-    context 'for integer config' do
-      it 'not raises error for valid params' do
-        expect {
-          described_class.new(integer_config).validate!({example_integer_config: 5})
-        }.not_to raise_error
-      end
-
-      it 'not raises error for valid params' do
-        expect {
-          described_class.new(integer_config).validate!({example_integer_config: 4})
-        }.to raise_error Rdm::Errors::InvalidConfig
-      end
-
-      it 'returns OpenStruct' do
-        expect(
-          described_class.new(integer_config).validate!({example_integer_config: 5})
-        ).to eq(OpenStruct.new({example_integer_config: 5}))
-      end
-    end
-
-    context 'for array config' do
-      it 'not raises error for valid params' do
-        expect {
-          described_class.new(symbol_config).validate!({example_array_config: ['hello', 'world']})
-        }.not_to raise_error
-      end
-
-      it 'returns OpenStruct' do
-        expect(
-          described_class.new(integer_config).validate!({example_array_config: ['hello', 'world']})
-        ).to eq(OpenStruct.new({example_array_config: ['hello', 'world']}))
-      end
-    end
-
-    context 'for hash config' do
-      it 'not raises error for valid params' do
-        expect {
-          described_class.new(symbol_config).validate!({example_array_config: ['hello', 'world']})
-        }.not_to raise_error
-      end
-
-      it 'returns OpenStruct' do
-        expect(
-          described_class.new(integer_config).validate!(
-            {
-              example_array_config: ['hello', 'world'],
-              example_integer_config: 5,
-              example_email_config: 'hello@world.pro',
-              example_symbol_config: :example
-            }
-          )
-        ).to match(
-          OpenStruct.new(
-            {
-              example_array_config:   ['hello', 'world'],
-              example_integer_config: 5,
-              example_email_config:   'hello@world.pro',
-              example_symbol_config:  :example
-            }
-          )
-        )
-      end
-    end
-  end
-end