active_typed_params 0.1.0

data/lib/active_typed_params/schema.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module ActiveTypedParams
+  class Schema
+    OPTIONS = %i[unknown required memoize root source].freeze
+    UNKNOWN_MODES = %i[ignore report reject].freeze
+    MUTEX = Mutex.new
+
+    attr_reader :owner, :name, :options, :compiled_module
+
+    def initialize(name:, owner: nil, options: {}, block: nil, nodes: nil, module_name: nil)
+      raise SchemaError, "typed_params #{name.inspect} needs a block" if block.nil? && nodes.nil?
+
+      unknown = options.keys - OPTIONS
+      raise SchemaError, "typed_params #{name.inspect} does not accept #{unknown.inspect}" if unknown.any?
+      unless UNKNOWN_MODES.include?(options.fetch(:unknown, :ignore))
+        raise SchemaError, "typed_params #{name.inspect} unknown: must be one of #{UNKNOWN_MODES.inspect}"
+      end
+
+      raise SchemaError, "typed_params #{name.inspect} source: must be a proc" if options.key?(:source) && !options[:source].is_a?(Proc)
+
+      @owner = owner
+      @name = name.to_sym
+      @options = options.freeze
+      @block = block
+      @nodes = nodes&.freeze
+      @module_name = module_name
+    end
+
+    # With `root:`, the block declares the keys of that required hash, as
+    # `params.require(:root).permit(...)` does, and the result is the inner hash.
+    def nodes
+      @nodes ||= begin
+        nodes = Builder.run(@block, required: options.fetch(:required, false), owner:)
+        root ? [Node.build(key: root, type: :hash, required: true, children: nodes)] : nodes
+      end
+    end
+
+    def root
+      options[:root]&.to_sym
+    end
+
+    # A proc run on the controller for the params to validate, such as
+    # `-> { params.fetch(:contact, {}) }`, instead of all of `params`.
+    def params_source
+      options[:source]
+    end
+
+    def unknown_mode
+      options.fetch(:unknown, :ignore)
+    end
+
+    # One line per key with its type, nested keys indented and `?` marking an
+    # optional key, so a snapshot shows what a request can set.
+    def describe
+      Schema.describe_nodes(nodes, 0).join("\n")
+    end
+
+    def self.describe_nodes(nodes, depth)
+      nodes.flat_map { |node| ["#{"  " * depth}#{node.key}: #{describe_type(node)}#{"?" unless node.required}", *describe_children(node, depth + 1)] }
+    end
+
+    def self.describe_type(node)
+      case node.type
+      when :array then "array(#{describe_type(node.item)}#{describe_cap(node.max_length)})"
+      when :map then "map(#{node.map_key.type} => #{describe_type(node.item)}#{describe_cap(node.max_length)})"
+      when :hash then node.open ? "hash(open)" : "hash"
+      when :one_of then "one_of(#{node.children.map { |alternative| describe_type(alternative) }.join(", ")})"
+      when :string then describe_string(node.max_length)
+      else node.type.to_s
+      end
+    end
+
+    def self.describe_cap(max_length)
+      case max_length
+      when Builder::DEFAULT_COLLECTION_MAX_LENGTH then ""
+      when nil then ", uncapped"
+      else ", #{max_length}"
+      end
+    end
+
+    def self.describe_string(max_length)
+      case max_length
+      when Builder::DEFAULT_STRING_MAX_LENGTH then "string"
+      when ActiveTypedParams.config.text_max_length then "text"
+      when nil then "string(uncapped)"
+      else "string(#{max_length})"
+      end
+    end
+
+    def self.describe_children(node, depth)
+      holder = (node.array? || node.map?) ? node.item : node
+      holder.hash? ? describe_nodes(holder.children, depth) : []
+    end
+
+    def memoize?
+      options.fetch(:memoize, false)
+    end
+
+    def memo_ivar
+      "@__typed_params_#{name}"
+    end
+
+    # Validates params outside a controller, as a definition owned by a plain
+    # object does. Procs and conditions run on the context, which also names
+    # the report.
+    def validate(params, context: nil, request: nil)
+      call(context || Object.new, params, request)
+    end
+
+    def source
+      (@compiler || Compiler.new(self)).source
+    end
+
+    def installed?
+      @installed
+    end
+
+    # Defines the real method on a module included in the owner after the stub
+    # module, so it takes precedence over the stub while an override on the
+    # owner or a subclass still reaches it with `super`.
+    def install!
+      return if @installed
+
+      MUTEX.synchronize do
+        return if @installed
+
+        @compiled_module = compile
+        @method = @compiled_module.instance_method(name)
+        owner&.include(@compiled_module)
+        @compiler = nil
+        @installed = true
+      end
+    end
+
+    # Runs the installed method on any object, bypassing an override on a
+    # controller; a definition validates whatever params it is given.
+    def call(context, *arguments)
+      install!
+      @method.bind_call(context, *arguments)
+    end
+
+    def request_available?
+      return @request_available if defined?(@request_available)
+
+      @request_available = case owner
+      when nil then false
+      when Class then owner.method_defined?(:request) || owner.private_method_defined?(:request)
+      else true
+      end
+    end
+
+    def module_name
+      @module_name ||= begin
+        base = owner.nil? ? "Definition" : (owner.name || "Anonymous_#{owner.object_id}")
+        "#{base.gsub("::", "_")}__#{name}"
+      end
+    end
+
+  private
+
+    def compiler
+      @compiler ||= Compiler.new(self)
+    end
+
+    def compile
+      generated = compiler.source
+      Module.new.tap do |mod|
+        mod.set_temporary_name("active_typed_params/#{module_name}")
+        compiler.constants.each { |constant, value| mod.const_set(constant, value) }
+        mod.module_eval(generated, "active_typed_params/#{module_name}", 1)
+        mod.send(:private, name)
+      end
+    end
+  end
+end

data/lib/active_typed_params/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveTypedParams
+  VERSION = "0.1.0"
+end

data/lib/active_typed_params.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require "bigdecimal"
+require "date"
+require "time"
+require "active_support"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/notifications"
+require "action_controller"
+
+require "active_typed_params/version"
+require "active_typed_params/errors"
+require "active_typed_params/node"
+require "active_typed_params/enum_adapter"
+require "active_typed_params/runtime"
+require "active_typed_params/declaration"
+require "active_typed_params/builder"
+require "active_typed_params/compiler"
+require "active_typed_params/schema"
+require "active_typed_params/inline"
+require "active_typed_params/controller"
+require "active_typed_params/inference"
+require "active_typed_params/railtie" if defined?(Rails::Railtie)
+
+# Typed, compiled request parameters: see the `typed_params` controller DSL.
+module ActiveTypedParams
+  class Configuration
+    # Each adapter receives the source given to `enum` and returns a Hash from
+    # raw request value to returned value, or nil when it does not handle it.
+    attr_accessor :enum_adapters
+
+    attr_accessor :file_classes
+
+    # The cap for `text` and for strings inference leaves to the model or the
+    # interaction: long, but bounded.
+    attr_accessor :text_max_length
+
+    # Each inferrer receives an ActiveModel attribute type and returns a
+    # Declaration, or nil when it does not handle it.
+    attr_accessor :type_inferrers
+
+    # Filter names `inputs_from` never declares, for inputs every interaction shares.
+    attr_accessor :ignored_filters
+
+    # Each inferrer receives an ActiveInteraction filter and returns a
+    # Declaration, or nil when it does not handle it.
+    attr_accessor :filter_inferrers
+
+    def initialize
+      @enum_adapters = []
+      @type_inferrers = []
+      @ignored_filters = []
+      @filter_inferrers = []
+      @text_max_length = 65_535
+      @file_classes = []
+      @file_classes << ActionDispatch::Http::UploadedFile if defined?(ActionDispatch::Http::UploadedFile)
+      @file_classes << Rack::Test::UploadedFile if defined?(Rack::Test::UploadedFile)
+    end
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+
+    # A definition survives code reloading, so one declared in an initializer
+    # must not reference reloadable classes, such as models or enums. Declare
+    # it beside the model instead, where reloading declares it again.
+    def define(name, **options, &block)
+      definitions[name.to_sym] = Schema.new(name:, options:, block:)
+    end
+
+    # Keys to merge with `use`, kept beside the model they describe, with no
+    # method and no global name: `IDEA_PARAMS = ActiveTypedParams.fragment { … }`.
+    def fragment(&block)
+      Schema.new(name: :fragment, block:)
+    end
+
+    def definition(name)
+      definitions.fetch(name.to_sym) { raise SchemaError, "no schema defined as #{name.inspect}" }
+    end
+
+    def register(schema)
+      (registry[schema.owner] ||= {})[schema.name] = schema
+    end
+
+    def schema(owner, name)
+      registry.dig(owner, name.to_sym) || raise(SchemaError, "#{owner} declares no typed_params #{name.inspect}")
+    end
+
+    # A schema declared on the owner or one of its ancestors, or else a global definition.
+    def find_schema(owner, name)
+      owner&.ancestors&.each do |ancestor|
+        schema = registry.dig(ancestor, name.to_sym)
+        return schema if schema
+      end
+      definition(name)
+    end
+
+    def source(owner, name)
+      schema(owner, name).source
+    end
+
+    def schemas
+      registry.values.flat_map(&:values)
+    end
+
+    # Every schema a controller or a global definition declares, as a snapshot spec lists them.
+    def all_schemas
+      schemas + definitions.values
+    end
+
+    def compile_all!
+      all_schemas.each(&:install!)
+    end
+
+    def inline_schema(key)
+      inline_schemas[key] ||= yield
+    end
+
+    # Code reloading replaces controller classes, which register their schemas
+    # again on load; schemas registered with `define` live in initializers and stay.
+    def unload!
+      registry.clear
+      inline_schemas.clear
+    end
+
+  private
+
+    def registry
+      @registry ||= {}
+    end
+
+    def definitions
+      @definitions ||= {}
+    end
+
+    def inline_schemas
+      @inline_schemas ||= {}
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: active_typed_params
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Máximo Mussini
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: Declare the keys and types a controller action accepts. Bad requests
+  are rejected with a 400 that names the parameter, and each declaration is compiled
+  into a single method, several times faster than params.permit.
+email:
+- maximomussini@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/active_typed_params.rb
+- lib/active_typed_params/builder.rb
+- lib/active_typed_params/compiler.rb
+- lib/active_typed_params/controller.rb
+- lib/active_typed_params/declaration.rb
+- lib/active_typed_params/enum_adapter.rb
+- lib/active_typed_params/errors.rb
+- lib/active_typed_params/inference.rb
+- lib/active_typed_params/inline.rb
+- lib/active_typed_params/node.rb
+- lib/active_typed_params/railtie.rb
+- lib/active_typed_params/runtime.rb
+- lib/active_typed_params/schema.rb
+- lib/active_typed_params/version.rb
+homepage: https://github.com/ElMassimo/active_typed_params
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ElMassimo/active_typed_params
+  changelog_uri: https://github.com/ElMassimo/active_typed_params/blob/main/CHANGELOG.md
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Typed strong parameters for Rails controllers, compiled into plain Ruby methods.
+test_files: []