rdm 0.4.14.2 → 0.4.17

data/lib/rdm/settings.rb

@@ -2,33 +2,22 @@ class Rdm::Settings
   attr_reader :settings
 
   SETTING_KEYS = [
-    :role, :package_subdir_name, :configs_dir, :config_path, :role_config_path,
+    :role, :package_subdir_name, :config_path,
     :silence_missing_package_file, :silence_missing_package, :compile_path,
-    :compile_ignore_files, :compile_add_files, :env_files_dir, :env_file_name
+    :compile_ignore_files, :compile_add_files
   ].freeze
 
-  SETTING_VARIABLES = [:role, :configs_dir, :config_path, :role_config_path].freeze
+  SETTING_VARIABLES = [:role].freeze
 
   # Default settings
   def initialize
-    silence_missing_package(false)
-    silence_missing_package_file(false)
-    package_subdir_name('package')
-    configs_dir('configs')
-    env_files_dir('env_files')
-    compile_ignore_files([
-      '.gitignore',
-      '.byebug_history',
-      '.irbrc',
-      '.rspec',
-      '*_spec.rb',
-      '*.log'
-    ])
-    compile_add_files([
-      'Gemfile',
-      'Gemfile.lock'
-    ])
-    compile_path('/tmp/rdm/:package_name')
+    silence_missing_package       false
+    silence_missing_package_file  false
+    package_subdir_name           'package'
+    compile_ignore_files          %w(.gitignore .byebug_history .irbrc .rspec *_spec.rb *.log)
+    compile_add_files             %w(Gemfile Gemfile.lock)
+    compile_path                  '/tmp/rdm/:package_name'
+    config_path                   'config/:role.yml'
   end
 
   SETTING_KEYS.each do |key|

data/lib/rdm/source.rb

@@ -3,7 +3,6 @@ class Rdm::Source
 
   def initialize(root_path:)
     @root_path = root_path
-    @config_names = []
     @package_paths = []
   end
 
@@ -13,15 +12,6 @@ class Rdm::Source
     @setup_block = block
   end
 
-  # Add config to list of known configs
-  # @param config_name [String] Config name
-  def config(config_name)
-    config_name = config_name.to_s
-    raise Rdm::Errors::ConfigExists, config_name if @config_names.include?(config_name)
-
-    @config_names << config_name
-  end
-
   # Add package to list of known packages
   # @param package_path [String] Package path
   def package(package_path)
@@ -32,9 +22,8 @@ class Rdm::Source
   # @param value [Hash<String: Rdm::Package>] Hash of packages by it's name
   # @param value [Hash<String: Rdm::Config>] Hash of configs by it's name
   # @return [Hash<String: Rdm::Package>] Hash of packages by it's name
-  def init_with(packages:, configs:)
+  def init_with(packages:)
     @packages = packages
-    @configs = configs
   end
 
   # Read initialized packages
@@ -42,10 +31,4 @@ class Rdm::Source
   def packages
     @packages || {}
   end
-
-  # Read initialized configs
-  # @return [Hash<String: Rdm::Config>] Hash of configs by it's name
-  def configs
-    @configs || {}
-  end
 end

data/lib/rdm/source_parser.rb

@@ -15,7 +15,7 @@ class Rdm::SourceParser
     @stdout      = stdout || STDOUT
   end
 
-  # Read source file, parse and init it's packages and configs
+  # Read source file, parse and init it's packages
   # @param source_path [String] Source file path
   # @return [Rdm::Source] Source
   def read_and_init_source
@@ -28,9 +28,7 @@ class Rdm::SourceParser
     validate_rdm_settings!
 
     init_and_set_packages(source)
-    init_and_set_configs(source)
-    init_and_set_env_variables(source)
-    source.init_with(packages: packages, configs: configs)
+    source.init_with(packages: packages)
     source
   end
 
@@ -57,37 +55,6 @@ class Rdm::SourceParser
     end
   end
 
-  def init_and_set_configs(source)
-    source.config_names.each do |config_name|
-      default_path         = settings.read_setting(:config_path, vars: { config_name: config_name })
-      role_path            = settings.read_setting(:role_config_path, vars: { config_name: config_name })
-      config               = Rdm::Config.new
-      config.default_path  = default_path
-      config.role_path     = role_path
-      config.name          = config_name
-      configs[config_name] = config
-    end
-  end
-
-  def init_and_set_env_variables(source)
-    return unless settings.read_setting(:env_file_name)
-    
-    unless File.exists?(env_file_path)
-      @stdout.puts "WARNING! Environment file '#{settings.read_setting(:env_file_name)}' was not found. Please, add #{env_file_path} file..."
-      return
-    end
-
-    File.foreach(env_file_path) do |line|
-      key, value = line.split('=').map(&:strip)
-      
-      if ENV.has_key?(key) && ENV[key] != value
-        @stdout.puts "WARNING! Environment file '#{settings.read_setting(:env_file_name)}' overwrites ENV['#{key}'] variable from '#{ENV.fetch(key, nil)}' to '#{value}' ..."
-      end
-      
-      ENV[key] = value
-    end
-  end
-
   # Make sure that all required settings are in place
   def validate_rdm_settings!
     if settings.read_setting(:role).nil?
@@ -102,12 +69,6 @@ class Rdm::SourceParser
     File.dirname(source_path)
   end
 
-  def env_file_path
-    file_path = File.join(root_path, settings.read_setting(:env_files_dir), "#{settings.read_setting(:env_file_name)}")
-
-    file_path.gsub(/\.env$/, '').concat('.env')
-  end
-
   # [String] Source file content
   def source_content
     @source_content ||= File.read(source_path)
@@ -117,10 +78,6 @@ class Rdm::SourceParser
     @packages ||= {}
   end
 
-  def configs
-    @configs ||= {}
-  end
-
   def settings
     Rdm.settings
   end

data/lib/rdm/templates/init/Rdm.packages

@@ -3,22 +3,10 @@ setup do
     ENV['RUBY_ENV'] || raise('please set RUBY_ENV environment variable')
   end
 
-  env_file_name do
-    ENV['ENV_FILE']
-  end
-
-  configs_dir             'configs'
-  config_path             ':configs_dir/:config_name/default.yml'
-  role_config_path        ':configs_dir/:config_name/:role.yml'
-
-  env_files_dir           'env_files'
   package_subdir_name     'package'
   silence_missing_package true
 end
 
-config :database
-config :logging
-
 
 # package 'core/application/commands'
 # package 'core/utils'

data/lib/rdm/utils/ostruct_utils.rb

@@ -0,0 +1,12 @@
+require 'ostruct'
+
+class Rdm::Utils::Ostruct
+  class << self
+    def to_recursive_ostruct(hash)
+      OpenStruct.new(hash.each_with_object({}) do |(key, val), memo|
+        memo[key] = val.is_a?(Hash) ? to_recursive_ostruct(val) : val
+      end)
+    end
+  end
+end
+

data/lib/rdm/version.rb

@@ -1,3 +1,3 @@
 module Rdm
-  VERSION = '0.4.14.2'.freeze
+  VERSION = '0.4.17'.freeze
 end

data/lib/rdm/yml_config/config_caster.rb

@@ -0,0 +1,32 @@
+require 'morf'
+
+class Rdm::ConfigCaster
+  def initialize(envs)
+    @envs = envs
+  end
+
+  def cast(hash)
+    hash[@envs.name] ||= {}
+    caster.cast(hash, input_keys: :string, skip_unexpected_attributes: true)
+  end
+  
+
+  def to_hcast_string(env)
+    eval_string = "#{env.type} :#{env.name}, optional: #{env.optional}"
+    eval_string += env.is_array? ? ", each: :#{env.children.first.type}" : ""
+    eval_string += env.is_hash? ? %Q( do \n  #{env.children.map { |e| to_hcast_string(e) }.join("\n")} \nend) : ""
+
+    eval_string
+  end
+
+  private
+
+  def caster
+    @caster ||= Class.new
+    @caster.include(Morf::Caster)
+
+    @caster.class_eval "attributes do\n #{to_hcast_string(@envs)}\n end"
+
+    @caster
+  end
+end

data/lib/rdm/yml_config/config_manager.rb

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,92 @@
+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