hierarchical_config 0.11 → 0.13

data/lib/hierarchical_config.rb

@@ -1,84 +1,174 @@
-require 'ostruct'
+# typed: strict
+
 require 'yaml'
 require 'erb'
 require 'set'
+require 'sorbet-runtime'
+require 'active_support'
+require 'active_support/core_ext/hash/keys'
 
-require "hierarchical_config/version"
+require 'hierarchical_config/version'
 
 module HierarchicalConfig
   REQUIRED = :REQUIRED
-  #this is the incantation that works for ruby 1.8.7 (syck)
-  YAML.add_builtin_type( 'REQUIRED' ){ REQUIRED }
-  #and this works for 1.9.3 (Psych)
-  YAML.add_domain_type( nil, 'REQUIRED' ){ REQUIRED }
-
-  class OpenStruct < ::OpenStruct
-    def method_missing( mid, *args ) # :nodoc:
-      mname = mid.id2name
-      len = args.length
-      if mname.chomp!('=')
-        if len != 1
-          raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
-        end
-        modifiable[new_ostruct_member(mname)] = args[0]
-      elsif mname =~ /\?$/
-        !!send(mname.gsub("?",""))
-      elsif len == 0 && @table.key?( mid )
-        @table[mid]
+  T.unsafe(YAML).add_domain_type(nil, 'REQUIRED'){REQUIRED}
+
+  ClassOrModule = T.type_alias{T.any(Class, Module)}
+
+  module ConfigStruct
+    extend T::Sig
+    include Kernel
+
+    sig{returns(T::Hash[Symbol, T.untyped])}
+    def to_hash
+      Hash[self.class.props.keys.map{|key| [key, item_to_hash(send(key))]}] # rubocop:disable Style/HashConversion
+    end
+
+    sig{params(key: T.any(String, Symbol)).returns(T.untyped)}
+    def [](key)
+      send(key)
+    end
+
+    private
+
+    sig{params(item: BasicObject).returns(T.any(BasicObject, T::Hash[T.untyped, T.untyped]))}
+    def item_to_hash(item)
+      case item
+      when ConfigStruct
+        item.to_hash
+      when Array
+        item.map{|i| item_to_hash(i)}
       else
-        raise NoMethodError, "undefined method `#{mname}' for #{self}", caller(1)
+        item
       end
     end
+  end
+
+  @@root_index = T.let(0, Integer) # rubocop:disable Style/ClassVars
 
-    def [](attribute)
-      send(attribute)
+  class << self
+    extend T::Sig
+
+    sig{params(value: T.untyped, path: String).returns(T::Array[String])}
+    def detect_errors(value, path)
+      errors = T.let([], T::Array[String])
+      case value
+      when Hash
+        value.each do |key, item|
+          errors += detect_errors(item, "#{path}.#{key}")
+        end
+      when Array
+        value.each_with_index do |item, index|
+          errors += detect_errors(item, "#{path}[#{index}]")
+        end
+      when REQUIRED
+        errors << "#{path} is REQUIRED"
+      end
+      errors
     end
 
-    alias :each :each_pair
+    sig{params(current_item: Object, name: String, parent_class: ClassOrModule).returns(T.any(Class, T::Types::Base))}
+    def build_types(current_item, name, parent_class)
+      case current_item
+      when Hash
+        new_type_name = ActiveSupport::Inflector.camelize(ActiveSupport::Inflector.underscore(name))
+
+        return Hash if current_item.keys.to_a.any?{|k| k =~ /^[0-9]/ || k =~ /[- ]/}
 
-    def to_hash
-      @table.inject({}) do |hash, key_value|
-        key, value = *key_value
-        hash[key] = item_to_hash(value)
-        hash
+        new_type =
+          if parent_class.const_defined?(new_type_name, false)
+            parent_class.const_get(new_type_name, false)
+          else
+            parent_class.const_set(new_type_name, Class.new(T::Struct).tap{|c| c.include ConfigStruct})
+          end
+
+        current_item.each do |key, value|
+          next if new_type.props.key?(key.to_sym)
+
+          new_type.const key.to_sym, build_types(value, key, new_type)
+          new_type.send(:define_method, "#{key}?") do
+            !!send(key)
+          end
+        end
+
+        new_type
+      when Array
+        types = current_item.each_with_index.map do |item, index|
+          build_types(item, "#{name}_#{index}", parent_class)
+        end
+        case types.size
+        when 0
+          T.untyped
+        when 1
+          T::Array[types.first]
+        else
+          T::Array[T.unsafe(T).any(*types)]
+        end
+      else
+        current_item.class
       end
     end
 
-    private
+    sig{params(current_item: Object, name: String, parent_class: ClassOrModule).returns(T.untyped)}
+    def build_config(current_item, name, parent_class)
+      case current_item
+      when Hash
+        return current_item.symbolize_keys if current_item.keys.to_a.any?{|k| k =~ /^[0-9]/ || k =~ /[- ]/}
 
-    def item_to_hash(value)
-      case value
+        current_type = parent_class.const_get(ActiveSupport::Inflector.camelize(name))
+        current_type.new(Hash[current_item.map{|key, value| [key.to_sym, build_config(value, key, current_type)]}]) # rubocop:disable Style/HashConversion
       when Array
-        value.map{|item| item_to_hash(item)}
-      when OpenStruct
-        value.to_hash
+        current_item.each_with_index.map do |item, index|
+          build_config(item, "#{name}_#{index}", parent_class)
+        end.freeze
       else
-        value
+        current_item.freeze
       end
     end
-  end
 
-  class << self
-    def load_config( name, dir, environment, preprocess_with=:erb )
+    sig{returns(Class)}
+    def build_new_root
+      @@root_index += 1 # rubocop:disable Style/ClassVars
+      const_set("ConfigRoot#{@@root_index}", Class.new)
+    end
+
+    sig do
+      params(
+        name: String,
+        dir: String,
+        environment: String,
+        preprocess_with: T.nilable(Symbol),
+        root_class: ClassOrModule,
+      ).returns(T::Struct)
+    end
+    def load_config(name, dir, environment, preprocess_with = :erb, root_class = build_new_root)
       primary_config_file   = "#{dir}/#{name}.yml"
       overrides_config_file = "#{dir}/#{name}-overrides.yml"
 
-      config_hash = load_hash_for_env( primary_config_file, environment, preprocess_with )
+      config_hash = load_hash_for_env(primary_config_file, environment, preprocess_with)
 
-      if File.exists?( overrides_config_file )
-        overrides_config_hash = load_hash_for_env( overrides_config_file, environment, preprocess_with )
-        config_hash = deep_merge( config_hash, overrides_config_hash )
+      if File.exist?(overrides_config_file)
+        overrides_config_hash = load_hash_for_env(overrides_config_file, environment, preprocess_with)
+        config_hash = deep_merge(config_hash, overrides_config_hash)
       end
 
-      config_hash, errors = lock_down_and_ostructify!( config_hash, name, environment )
+      errors = detect_errors(config_hash, name)
+      raise errors.map{|error| "#{error} for #{environment}"}.inspect unless errors.empty?
 
-      raise errors.inspect unless errors.empty?
+      build_types(config_hash, name, root_class)
 
-      config_hash
+      build_config(config_hash, name, root_class)
     end
 
-    def load_hash_for_env( file, environment, preprocess_with )
-      file_contents = IO.read(file)
+    sig do
+      params(
+        file: String,
+        environment: String,
+        preprocess_with: T.nilable(Symbol),
+      ).returns(T::Hash[String, BasicObject])
+    end
+    def load_hash_for_env(file, environment, preprocess_with)
+      file_contents = File.read(file)
       yaml_contents = case preprocess_with
                       when :erb
                         ERB.new(file_contents).result
@@ -87,103 +177,75 @@ module HierarchicalConfig
                       else
                         raise "Unknown preprocessor <#{preprocess_with}>"
                       end
-      yaml_config   = YAML::load(yaml_contents)
+      yaml_config   = YAML.safe_load(yaml_contents)
 
       ordered_stanza_labels = []
       ordered_stanza_labels << 'defaults' if yaml_config.key? 'defaults'
-      ordered_stanza_labels += yaml_config.keys.grep(/^defaults\[.*#{environment}/).sort_by{ |a| a.count(',') }
+      ordered_stanza_labels += yaml_config.keys.grep(/^defaults\[.*#{environment}/).sort_by{|a| a.count(',')}
       ordered_stanza_labels << environment if yaml_config.key? environment
 
       config = deep_merge_hashes_in_keys(ordered_stanza_labels, yaml_config)
 
       env_config_labels = []
       env_config_labels << 'env_vars' if yaml_config.key? 'env_vars'
-      env_config_labels += yaml_config.keys.grep(/^env_vars\[.*#{environment}/).sort_by{ |a| a.count(',') }
+      env_config_labels += yaml_config.keys.grep(/^env_vars\[.*#{environment}/).sort_by{|a| a.count(',')}
 
       env_config = deep_merge_hashes_in_keys(env_config_labels, yaml_config)
       env_config = fill_in_env_vars(env_config)
 
       deep_merge(config, env_config)
-
     rescue StandardError => e
       raise <<-ERROR
         Error loading config from file #{file}.
-        #{$!.inspect}
-        #{$@}
+        #{$ERROR_INFO.inspect}
+        #{$ERROR_POSITION}
+        #{e}
       ERROR
     end
 
     private
 
+    sig do
+      params(keys: T::Array[String],
+             root_hash: T::Hash[String,
+                                T::Hash[String, T.untyped]]).returns(T::Hash[T.untyped, T.untyped])
+    end
     def deep_merge_hashes_in_keys(keys, root_hash)
       keys.inject({}) do |acc, label|
-        deep_merge( acc, root_hash[label] )
+        deep_merge(acc, T.must(root_hash[label]))
       end
     end
 
+    sig{params(hash: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped])}
     def fill_in_env_vars(hash)
       r = {}
-      hash.each do |key,value|
+      hash.each do |key, value|
         if value.is_a? Hash
           leaf_hash = fill_in_env_vars(value)
-          r[key]=leaf_hash unless leaf_hash.keys.empty?
+          r[key] = leaf_hash unless leaf_hash.keys.empty?
         elsif !value.nil? && ENV.key?(value)
-          r[key]=ENV[value]
+          r[key] = ENV.fetch(value, nil)
         end
       end
       r
     end
 
     # merges two hashes with nested hashes if present
-    def deep_merge( hash1, hash2 )
+    sig do
+      params(hash1: T::Hash[T.untyped, T.untyped],
+             hash2: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped])
+    end
+    def deep_merge(hash1, hash2)
       hash1 = hash1.dup
-      ( hash1.keys + hash2.keys ).each do | key |
-        if hash1.key?( key ) && hash2.key?( key ) &&
-           hash1[key].is_a?( Hash ) && hash2[key].is_a?( Hash )
-           hash1[key] = deep_merge( hash1[key], hash2[key] )
-        elsif hash2.key?( key )
+      (hash1.keys + hash2.keys).each do |key|
+        if hash1.key?(key) && hash2.key?(key) &&
+           hash1[key].is_a?(Hash) && hash2[key].is_a?(Hash)
+          hash1[key] = deep_merge(hash1[key], hash2[key])
+        elsif hash2.key?(key)
           hash1[key] = hash2[key]
         end
       end
       hash1
     end
-
-    # Mutator method that does three things:
-    # * checks if any of the keys were required and not set. Upon finding
-    # it adds key to the error set
-    # * recursively sets open structs for deep hashes
-    # * recursively freezes config objects
-    def lock_down_and_ostructify!( _hash, path, environment)
-      hash = Hash[_hash.map{|k,v|[k.to_s, v]}] #stringify keys
-      errors = []
-      hash.each do | key, value |
-        hash[key], child_errors = lock_down_and_ostructify_item!(value, path + '.' + key, environment)
-        errors += child_errors
-      end
-      return OpenStruct.new(hash).freeze, errors
-    end
-
-    def lock_down_and_ostructify_item!(value, path, environment)
-      errors = []
-      return_value = case value
-      when Hash
-        child_hash, child_errors = lock_down_and_ostructify!( value, path, environment )
-        errors += child_errors
-        child_hash
-      when Array
-        value.each_with_index.map do |item, index|
-          child_item, child_errors = lock_down_and_ostructify_item!( item, "#{path}[#{index}]", environment )
-          errors += child_errors
-          child_item
-        end.freeze
-      when REQUIRED
-        errors << "#{path} is REQUIRED for #{environment}"
-        nil
-      else
-        value.freeze
-      end
-
-      return return_value, errors
-    end
   end
 end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.

data/sorbet/rbi/annotations/activesupport.rbi

@@ -0,0 +1,128 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module ActiveSupport::Testing::Declarative
+  sig { params(name: String, block: T.proc.bind(T.untyped).void).void }
+  def test(name, &block); end
+end
+
+class ActiveSupport::EnvironmentInquirer
+  sig { returns(T::Boolean) }
+  def development?; end
+
+  sig { returns(T::Boolean) }
+  def production?; end
+
+  sig { returns(T::Boolean) }
+  def test?; end
+
+  # @method_missing: delegated to String through ActiveSupport::StringInquirer
+  sig { returns(T::Boolean) }
+  def staging?; end
+end
+
+module ActiveSupport::Testing::SetupAndTeardown::ClassMethods
+  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.untyped).void)).void }
+  def setup(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.untyped).void)).void }
+  def teardown(*args, &block); end
+end
+
+class ActiveSupport::TestCase
+  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).void)).void }
+  def self.setup(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).void)).void }
+  def self.teardown(*args, &block); end
+
+  sig { params(name: String, block: T.proc.bind(T.attached_class).void).void }
+  def self.test(name, &block); end
+end
+
+class Object
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { returns(T::Boolean) }
+  def present?; end
+end
+
+class Hash
+  sig { returns(T::Boolean) }
+  def extractable_options?; end
+end
+
+class Array
+  sig { params(position: Integer).returns(T.self_type) }
+  def from(position); end
+
+  sig { params(position: Integer).returns(T.self_type) }
+  def to(position); end
+
+  sig { params(elements: T.untyped).returns(T::Array[T.untyped]) }
+  def including(*elements); end
+
+  sig { params(elements: T.untyped).returns(T.self_type) }
+  def excluding(*elements); end
+
+  sig { params(elements: T.untyped).returns(T.self_type) }
+  def without(*elements); end
+
+  sig { returns(T.nilable(Elem)) }
+  def second; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third; end
+
+  sig { returns(T.nilable(Elem)) }
+  def fourth; end
+
+  sig { returns(T.nilable(Elem)) }
+  def fifth; end
+
+  sig { returns(T.nilable(Elem)) }
+  def forty_two; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third_to_last; end
+
+  sig { returns(T.nilable(Elem)) }
+  def second_to_last; end
+
+  sig { params(options: T::Hash[T.untyped, T.untyped]).returns(String) }
+  def to_sentence(options = {}); end
+
+  sig { params(format: Symbol).returns(String) }
+  def to_fs(format = :default); end
+
+  sig { params(format: Symbol).returns(String) }
+  def to_formatted_s(format = :default); end
+
+  sig { returns(String) }
+  def to_xml; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def extract_options!; end
+
+  sig { type_parameters(:FillType).params(number: Integer, fill_with: T.type_parameter(:FillType), block: T.nilable(T.proc.params(group: T::Array[T.any(Elem, T.type_parameter(:FillType))]).void)).returns(T::Array[T::Array[T.any(Elem, T.type_parameter(:FillType))]]) }
+  def in_groups(number, fill_with = T.unsafe(nil), &block); end
+
+  sig { type_parameters(:FillType).params(number: Integer, fill_with: T.type_parameter(:FillType), block: T.nilable(T.proc.params(group: T::Array[T.any(Elem, T.type_parameter(:FillType))]).void)).returns(T::Array[T::Array[T.any(Elem, T.type_parameter(:FillType))]]) }
+  def in_groups_of(number, fill_with = T.unsafe(nil), &block); end
+
+  sig { params(value: T.untyped, block: T.nilable(T.proc.params(element: Elem).returns(T.untyped))).returns(T::Array[T::Array[Elem]]) }
+  def split(value = nil, &block); end
+
+  sig { params(object: T.untyped).returns(T::Array[T.untyped]) }
+  def self.wrap(object); end
+
+  sig { returns(T.untyped) }
+  def extract!; end
+
+  sig { returns(ActiveSupport::ArrayInquirer) }
+  def inquiry; end
+end