typed-config 1.3.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3551b257563c33aefb5d1da190ddc584bfb1893edc271c775d82ab3fe46c30f1
+  data.tar.gz: 2a7b822b9d3e22c2e4c678f4e00dd5b3618eb5d51ecd8210ff1af60c35f74d10
+SHA512:
+  metadata.gz: 1c0477d6708d339e692e504503685d4757a4d00d36b968d385cf920006993b70e529a99413b8ac958ebf9bbb15ca31bab86a80decf672aca17944f4f8089f45b
+  data.tar.gz: 12cc17789e2b9531a8dc05f8770c53dd0f5005af125351dd8833606137931f6a7d5615e752f84a4ea473023992f72f4dcdcda4aa16b4c95907ff2b36367c28af

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,109 @@
+# TypedConfig
+
+TypedConfig is a simple solution for managing multi-environment application
+settings whilst maintaining type safety.
+
+Currently, only Rails is supported out of the box.
+
+TypedConfig is meant to run in projects using [Sorbet](https://sorbet.org/),
+although it can run in projects not using it and still gain from the easy-to-configure
+settings.
+
+This project has been inspired by [Config](https://github.com/rubyconfig/config) and
+it's meant to be an easy drop-in replacement with type-safety.
+
+## Installing
+
+Add the gem to your `Gemfile`:
+```ruby
+gem 'typed-config'
+```
+
+Run the install rake task to initialize the config schema and settings files:
+```ruby
+rails g typed_config:install
+```
+
+This will generate the schema file `config/config.rb` where the schema of the
+settings should be defined, and the settings file:
+```
+config/settings.yml
+config/settings.local.yml
+config/settings/development.yml
+config/settings/production.yml
+config/settings/test.yml
+```
+It will also update the existing `.gitignore` to local settings files.
+
+## Defining the Settings Properties
+First, the schema of the Settings object must be defined in the `config/config.rb`
+file, for example:
+```ruby
+TypedConfig::Schema.configure do |s|
+  s.const :env, String
+  s.const :app do
+    s.const :domain, T.nilable(String)
+    s.const :port, T.nilable(Integer)
+  end
+  s.const :support do
+    s.const :email, String
+  end
+end
+```
+
+Now in the code, you can access any properties as a `T::Struct`. All properties will be
+available across the application in a `Settings` object:
+```ruby
+Settings.env
+Settting.support.email
+
+# Example:
+config.action_mailer.asset_host = "https://#{Settings.app.domain}"
+```
+
+## Changing the Settings
+The settings are defined in YAML (with ERB support). Once the schema is defined, update
+one of the settings file to load the data:
+```yaml
+env: <%= ENV['RACK_ENV'] %>
+app:
+  domain: <%= ENV['APP_DOMAIN'] %>
+  port: <%= ENV.fetch('APP_PORT', 3000) %>
+support:
+  email: 'support@typed-config.com
+```
+When loaded, `typed-config` will try to automatically coerce the values to match the ones
+specified in the schema.
+
+You may define default (or different) settings for each environment by changing the
+`config/settings/#{env}.yml`. For instance, to have different defaults in the test
+environment, add the settings to `config/settings/test.yml`.
+
+In order from top to bottom - the settings in the lower files overwrite the ones higher -
+these are the files loaded:
+```
+config/settings.yml
+config/settings/#{environment}.yml
+
+config/settings.local.yml
+config/settings/#{environment}.local.yml
+```
+
+## Type Safety
+To make use of the type-safety feature, you must re-generate the RBI files when the schema
+is changed using a rake command:
+```shell
+bundle exec rake typed-config:rbi
+```
+
+Now you can run sorbet to check the types of the settings properties:
+```ruby
+T.reveal_type(Settings.app.domain) # Revealed type: T.nilable(String)
+
+sig { params(server_write_key: String).void }
+def configure_segment(server_write_key); end
+
+
+configure_segment(server_write_key: Settings.segment.server_write_key)
+# Expected String but found T.nilable(String) for argument server_write_key
+```

data/lib/generators/typed_config/install_generator.rb

@@ -0,0 +1,36 @@
+# typed: ignore
+# frozen_string_literal: true
+
+module TypedConfig
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc 'Generated typed-config files for Rails.'
+
+      source_root File.expand_path('templates', __dir__)
+
+      def copy_config
+        template 'config.rb', 'config/config.rb'
+      end
+
+      def copy_settings
+        template 'settings.yml', 'config/settings.yml'
+        template 'settings.local.yml', 'config/settings.local.yml'
+        directory 'settings', 'config/settings'
+      end
+
+      def modify_gitignore
+        create_file '.gitignore' unless File.file?('.gitignore')
+
+        append_to_file '.gitignore' do
+          "\nconfig/settings.local.yml\n" \
+            "config/settings/*.local.yml\n" \
+            "config/environments/*.local.yml\n"
+        end
+      end
+
+      def generate_rbi
+        rake 'typed-config:rbi'
+      end
+    end
+  end
+end

data/lib/generators/typed_config/templates/config.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+TypedConfig::Schema.configure do |s|
+  s.const :aws do
+    s.const :access_key_id, T.nilable(String)
+    s.const :secret_access_key, T.nilable(String)
+  end
+end

data/lib/generators/typed_config/templates/settings.local.yml

@@ -0,0 +1,3 @@
+aws:
+  access_key_id: test-access-key-id
+  secret_access_key: test-secret-access-key

data/lib/generators/typed_config/templates/settings.yml

@@ -0,0 +1,3 @@
+aws:
+  access_key_id: <%= ENV['AWS_ACCESS_KEY_ID'] %>
+  secret_access_key: <%= ENV['AWS_SECRET_ACCESS_KEY'] %>

data/lib/typed-config.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+require 'typed_config/version'
+require 'typed_config/setup'
+require 'typed_config/schema'
+
+require('typed_config/railtie') if defined?(::Rails)

data/lib/typed_config/loader.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'erb'
+require 'yaml'
+
+module TypedConfig
+  class Loader
+    extend T::Sig
+
+    sig { params(filename: String).returns(T::Hash[String, T.untyped]) }
+    def load(filename)
+      return {} unless File.file?(filename)
+
+      contents = File.read(filename)
+      yaml = YAML.safe_load(ERB.new(contents).result) || {}
+      T.cast(yaml, T::Hash[String, T.untyped])
+    end
+  end
+end

data/lib/typed_config/railtie.rb

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative 'setup'
+
+module TypedConfig
+  class Railtie < ::Rails::Railtie
+    railtie_name :typed_config
+
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+    end
+
+    def preload
+      Setup.new.call(
+        config_path: ::Rails.root.join('config'),
+        env: ::Rails.env,
+      )
+    end
+
+    config.before_configuration { T.unsafe(self).preload }
+  end
+end

data/lib/typed_config/rbi_builder.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'erb'
+
+module TypedConfig
+  class RBIBuilder
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @structs = T.let(
+        {},
+        T::Hash[
+          String,
+          T::Array[{ name: Symbol, type: String }],
+        ],
+      )
+    end
+
+    sig { params(struct: Class).void }
+    def add_struct(struct)
+      @structs[T.must(struct.name)] ||= []
+    end
+
+    sig { params(struct: Class, name: Symbol, type: T.untyped).void }
+    def add_const(struct, name, type)
+      add_struct(struct)
+      T.must(@structs[T.must(struct.name)]).push({ name: name, type: type.name })
+    end
+
+    sig { params(schema_const_name: String).returns(String) }
+    def build(schema_const_name)
+      b = binding
+      b.local_variable_set(:schema_const_name, schema_const_name)
+      b.local_variable_set(:structs, @structs)
+      template_file = File.read(File.join(File.dirname(__FILE__), 'structs.rbi.erb'))
+      ERB.new(template_file, trim_mode: '>').result(b)
+    end
+
+    private
+
+    sig { params(consts: T::Array[{ name: Symbol, type: String }]).returns(String) }
+    def build_consts(consts)
+      consts.inject('') do |prev, const|
+        prev + "  const :#{const[:name]}, #{const[:type]}\n"
+      end
+    end
+  end
+end

data/lib/typed_config/schema.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative './schema_builder'
+require_relative './structs/_structs'
+
+module TypedConfig
+  class Schema
+    @schema_builder = T.let(nil, T.nilable(SchemaBuilder))
+    @schema_const_name = T.let('Settings', String)
+
+    class << self
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :schema_const_name
+
+      sig do
+        params(
+          const_name: T.nilable(String),
+          _blk: T.proc.params(config: SchemaBuilder).void,
+        ).void
+      end
+      def configure(const_name = nil, &_blk)
+        @schema_const_name = const_name || schema_const_name
+        yield schema_builder
+      end
+
+      sig { returns(String) }
+      def rbi
+        schema_builder.build_rbi(schema_const_name)
+      end
+
+      private
+
+      sig { returns(SchemaBuilder) }
+      def schema_builder
+        @schema_builder ||= SchemaBuilder.new('Settings')
+      end
+    end
+  end
+end

data/lib/typed_config/schema_builder.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative './rbi_builder'
+require_relative './structs/_structs'
+
+module TypedConfig
+  class SchemaBuilder
+    extend T::Sig
+
+    sig { params(struct: String, rbi_builder: RBIBuilder).void }
+    def initialize(struct, rbi_builder: RBIBuilder.new)
+      @rbi_builder = rbi_builder
+      @struct = T.let(create_struct(Structs, struct), Class)
+    end
+
+    sig do
+      params(
+        name: Symbol,
+        type: T.untyped,
+        blk: T.nilable(T.proc.void),
+      ).void
+    end
+    def const(name, type = nil, &blk)
+      clazz = retrieve_class(name: name, type: type, &blk)
+      raise ArgumentError, "Attribute '#{name}' must receive a type or block." if clazz.nil?
+
+      rbi_builder.add_const(struct, name, clazz)
+      struct.tap do |scope|
+        scope.const name, clazz
+      end
+    end
+
+    sig { params(schema_const_name: String).returns(String) }
+    def build_rbi(schema_const_name)
+      rbi_builder.build(schema_const_name)
+    end
+
+    protected
+
+    sig { returns(Class) }
+    attr_reader :struct
+
+    sig { returns(RBIBuilder) }
+    attr_reader :rbi_builder
+
+    sig do
+      params(
+        name: Symbol,
+        type: T.untyped,
+        blk: T.nilable(T.proc.void),
+      ).returns(T.untyped)
+    end
+    def retrieve_class(name:, type:, &blk)
+      return type unless block_given?
+
+      process_substruct(name: name, &blk)
+    end
+
+    sig { params(name: Symbol, blk: T.proc.void).returns(Class) }
+    def process_substruct(name:, &blk)
+      top_struct = struct
+      sub_struct = create_struct(struct, name.to_s)
+      @struct = sub_struct
+      instance_eval(&blk)
+      @struct = top_struct
+      sub_struct
+    end
+
+    sig { params(base: T.any(Module, Class), name: String).returns(Class) }
+    def create_struct(base, name)
+      new_struct = base.const_set(name.camelcase, Class.new(T::Struct))
+      rbi_builder.add_struct(new_struct)
+      new_struct
+    end
+  end
+end

data/lib/typed_config/setup.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-coerce'
+require_relative './loader'
+require_relative './schema'
+
+module TypedConfig
+  class Setup
+    extend T::Sig
+
+    sig { params(loader: Loader).void }
+    def initialize(loader: Loader.new)
+      @loader = loader
+    end
+
+    sig { params(config_path: T.any(Pathname, String), env: String).void }
+    def call(config_path:, env: T.cast(ENV['RACK_ENV'], String))
+      config_file = "#{config_path}/config.rb"
+      return unless File.file?(config_file)
+
+      require_relative config_file
+
+      settings = build_settings(config_path: config_path, env: env)
+      definition = TypeCoerce[Structs::Settings].new.from(settings)
+      Object.const_set(Schema.schema_const_name, definition)
+    end
+
+    private
+
+    sig { returns(Loader) }
+    attr_reader :loader
+
+    sig do
+      params(config_path: T.any(Pathname, String), env: String)
+        .returns(T::Hash[String, T.untyped])
+    end
+    def build_settings(config_path:, env:)
+      merge_settings([
+        loader.load("#{config_path}/settings.yml"),
+        loader.load("#{config_path}/settings/#{env}.yml"),
+        loader.load("#{config_path}/settings.local.yml"),
+        loader.load("#{config_path}/settings/#{env}.local.yml"),
+      ])
+    end
+
+    sig do
+      params(values: T::Array[T::Hash[String, T.untyped]])
+        .returns(T::Hash[String, T.untyped])
+    end
+    def merge_settings(values)
+      values.inject({}) { |prev, curr| prev.deep_merge(curr) }
+    end
+  end
+end

data/lib/typed_config/structs.rbi.erb

@@ -0,0 +1,12 @@
+# typed: strong
+
+::<%= schema_const_name %> = T.let(nil, TypedConfig::Structs::Settings)
+<% structs.each do |struct_name, consts| %>
+
+class <%= struct_name %> < T::Struct
+<% consts.each do |const| %>
+  const :<%= const[:name] %>, <%= const[:type] %>
+
+<% end %>
+end
+<% end %>

data/lib/typed_config/structs/_structs.rb

@@ -0,0 +1,7 @@
+# typed: strong
+# frozen_string_literal: true
+
+module TypedConfig
+  module Structs
+  end
+end

data/lib/typed_config/structs/settings.rbi

@@ -0,0 +1,9 @@
+# typed: strong
+# frozen_string_literal: true
+
+module TypedConfig
+  module Structs
+    class Settings < T::Struct
+    end
+  end
+end

data/lib/typed_config/tasks/typed-config/rbi.rake

@@ -0,0 +1,12 @@
+# typed: false
+# frozen_string_literal: true
+
+namespace 'typed-config' do
+  task rbi: :environment do
+    puts 'Generating RBI files...'
+    rbi = TypedConfig::Schema.rbi
+    FileUtils.mkdir_p(::Rails.root.join('sorbet', 'typed-config'))
+    File.write(::Rails.root.join('sorbet', 'typed-config', 'structs.rbi'), rbi)
+    puts 'RBI files updated in sorbet/typed-config.'
+  end
+end

data/lib/typed_config/version.rb

@@ -0,0 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
+module TypedConfig
+  VERSION = '1.3.8'
+end

data/rbi/schema.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module TypedConfig
+  class Schema
+    extend T::Sig
+
+    sig do
+      params(
+        const_name: T.nilable(String),
+        blk: T.proc.params(config: SchemaBuilder).void,
+      ).void
+    end
+    def self.configure(const_name = nil, &blk); end
+  end
+end

data/rbi/schema_builder.rbi

@@ -0,0 +1,16 @@
+# typed: strong
+
+module TypedConfig
+  class SchemaBuilder
+    extend T::Sig
+
+    sig do
+      params(
+        name: Symbol,
+        type: T.untyped,
+        blk: T.nilable(T.proc.void),
+      ).void
+    end
+    def const(name, type = nil, &blk); end
+  end
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: typed-config
+version: !ruby/object:Gem::Version
+  version: 1.3.8
+platform: ruby
+authors:
+- Alex Santos
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: sorbet-coerce
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.4
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.84.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.84.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.39.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.39.0
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Manage multi-environment settings with type-safety in Ruby
+email: hello@alexcsantos.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- lib/generators/typed_config/install_generator.rb
+- lib/generators/typed_config/templates/config.rb
+- lib/generators/typed_config/templates/settings.local.yml
+- lib/generators/typed_config/templates/settings.yml
+- lib/generators/typed_config/templates/settings/development.yml
+- lib/generators/typed_config/templates/settings/production.yml
+- lib/generators/typed_config/templates/settings/test.yml
+- lib/typed-config.rb
+- lib/typed_config/loader.rb
+- lib/typed_config/railtie.rb
+- lib/typed_config/rbi_builder.rb
+- lib/typed_config/schema.rb
+- lib/typed_config/schema_builder.rb
+- lib/typed_config/setup.rb
+- lib/typed_config/structs.rbi.erb
+- lib/typed_config/structs/_structs.rb
+- lib/typed_config/structs/settings.rbi
+- lib/typed_config/tasks/typed-config/rbi.rake
+- lib/typed_config/version.rb
+- rbi/schema.rbi
+- rbi/schema_builder.rbi
+homepage: https://rubygems.org/gems/typed-config
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key:
+specification_version: 4
+summary: Type-safe settings for Rails
+test_files: []