kirei 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32afe7523ced76d4fa44aa5125fbd4aa5befeaba2ea25bc94f2322b6375c461f
-  data.tar.gz: e6c14a2d80e667ecbd438dc5cd4e6b698ab3e08da394a0a622c027958c8e17cb
+  metadata.gz: cea2982351607eeafadd7e8ee3bb3ce13ba2c7e1e37eed22fa2f5a124b625022
+  data.tar.gz: 84a47be77945fa7a2faf5950441290fde74293388467729f2eb52c1c6041d29b
 SHA512:
-  metadata.gz: ae26b16d43f88cc9639d64ce255f2ebe269c10ae2e55fc0ad06659e5ef5991562bd87b29b6a6731bff00a58a382d78096ac5f4cbc7a155419d69f706a4f013b7
-  data.tar.gz: a5a4b6e94f7e33eb30d49d46704c52276a492ca6ed744aa99646427dd587836e37783ddabf1fe23856a2bf88cf9812939369d066252fe09e941ec64b33b95cae
+  metadata.gz: 3b420ea6cbfce60bf741bfd85cbfeb310dfd71031519a6d5fcc330bff788d24a0df1ef7268abbdbe49a2f373f4ff5df413dc6cf1b83589f96a6f8867164ffcef
+  data.tar.gz: 061a15d94de3e73dcd8d41db48601bfa5390d59aa1438c322d590ec3c33db9da4dd38d1f9258bf37a13c248ded433883a6da9ff52d41ee5873ca13b0cda414ca

data/kirei.gemspec

@@ -13,10 +13,12 @@ Gem::Specification.new do |spec|
     "oss@dbl.works",
   ]
 
-  spec.summary = "Kirei is a strictly typed Ruby micro/REST-framework for building scaleable and performant APIs."
+  spec.summary = "Kirei is a strictly typed Ruby micro/REST-framework for building scaleable and performant microservices." # rubocop:disable Layout/LineLength
   spec.description = <<~TXT
-    Kirei's structure und developer experience is inspired by Rails, but it's not a Rails clone.
-    It's a framework that's built from the ground up to be strictly typed, performant and scaleable.
+    Kirei is a strictly typed Ruby micro/REST-framework for building scaleable and performant microservices.
+    It is built from the ground up to be clean and easy to use.
+    Kirei is based on Sequel as an ORM, Sorbet for typing, and Sinatra for routing.
+    It strives to have zero magic and to be as explicit as possible.
   TXT
   spec.homepage = "https://github.com/swiknaba/kirei"
   spec.license = "MIT"
@@ -29,6 +31,7 @@ Gem::Specification.new do |spec|
     "kirei.gemspec",
     ".irbrc",
     "lib/**/*",
+    # do not include RBIs for gems, because users might use different verions
     "sorbet/rbi/dsl/**/*.rbi",
     "sorbet/rbi/shims/**/*.rbi",
     "LICENSE",
@@ -41,14 +44,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Utilities
-  spec.add_dependency "activesupport", "~> 6.0"
   spec.add_dependency "oj", "~> 3.0"
   spec.add_dependency "rake", "~> 13.0"
   spec.add_dependency "sorbet-runtime", "~> 0.5"
   spec.add_dependency "tzinfo-data", "~> 1.0" # for containerized environments, e.g. on AWS ECS
 
   # Web server & routing
-  spec.add_dependency "puma", "~> 6.0"
   spec.add_dependency "sinatra", "~> 3.0"
   spec.add_dependency "sinatra-contrib", "~> 3.0"
 

data/lib/boot.rb

@@ -12,20 +12,13 @@
 require "bundler/setup"
 
 # Second: load all gems (runtime dependencies only)
+require "logger"
 require "sorbet-runtime"
 require "oj"
-require "active_support/all"
-require "puma"
 require "sinatra"
 require "sinatra/namespace" # from sinatra-contrib
 require "pg"
-require "sequel"
-# "sequel_pg" should be auto-required by "sequel"
-
-Oj.default_options = {
-  mode: :compat, # required to dump hashes with symbol-keys
-  symbol_keys: false, # T::Struct.new works only with string-keys
-}
+require "sequel" # "sequel_pg" is auto-required by "sequel"
 
 # Third: load all application code
 Dir[File.join(__dir__, "kirei/**/*.rb")].each { require(_1) }

data/lib/cli/commands/new_app/execute.rb

@@ -1,7 +1,6 @@
 # typed: false
 
 require "fileutils"
-require "active_support/all"
 
 module Cli
   module Commands
@@ -12,7 +11,9 @@ module Cli
           Files::App.call(app_name)
           Files::Irbrc.call
 
-          puts "Kirei app '#{app_name}' scaffolded successfully!" # rubocop:disable all
+          Kirei::Logger.logger.info(
+            "Kirei app '#{app_name}' scaffolded successfully!",
+          )
         end
       end
     end

data/lib/cli/commands/start.rb

@@ -1,7 +1,6 @@
-# typed: false
+# typed: true
 
 require "fileutils"
-require "active_support/all"
 
 module Cli
   module Commands
@@ -10,10 +9,11 @@ module Cli
         case args[0]
         when "new"
           app_name = args[1] || "MyApp"
+          # @TODO(lud, 31.12.2023): classify is from ActiveSupport -> remove this?
           app_name = app_name.gsub(/[-\s]/, "_").classify
           NewApp::Execute.call(app_name: app_name)
         else
-          puts "Unknown command" # rubocop:disable all
+          Kirei::Logger.logger.info("Unknown command")
         end
       end
     end

data/lib/kirei/app_base.rb

@@ -55,7 +55,12 @@ module Kirei
         @raw_db_connection = Sequel.connect(AppBase.config.db_url || default_db_url)
 
         config.db_extensions.each do |ext|
-          @raw_db_connection.extension(ext)
+          T.cast(@raw_db_connection, Sequel::Database).extension(ext)
+        end
+
+        if config.db_extensions.include?(:pg_json)
+          # https://github.com/jeremyevans/sequel/blob/5.75.0/lib/sequel/extensions/pg_json.rb#L8
+          @raw_db_connection.wrap_json_primitives = true
         end
 
         @raw_db_connection

data/lib/kirei/base_model.rb

@@ -16,10 +16,37 @@ module Kirei
       ).returns(T.self_type)
     end
     def update(hash)
+      hash[:updated_at] = Time.now.utc if respond_to?(:updated_at) && hash[:updated_at].nil?
+      self.class.wrap_jsonb_non_primivitives!(hash)
       self.class.db.where({ id: id }).update(hash)
       self.class.find_by({ id: id })
     end
 
+    # Delete keeps the original object intact. Returns true if the record was deleted.
+    # Calling delete multiple times will return false after the first (successful) call.
+    sig { returns(T::Boolean) }
+    def delete
+      count = self.class.db.where({ id: id }).delete
+      count == 1
+    end
+
+    # warning: this is not concurrency-safe
+    # save keeps the original object intact, and returns a new object with the updated values.
+    sig { returns(T.self_type) }
+    def save
+      previous_record = self.class.find_by({ id: id })
+
+      hash = serialize
+      Helpers.deep_symbolize_keys!(hash)
+      hash = T.cast(hash, T::Hash[Symbol, T.untyped])
+
+      if previous_record.nil?
+        self.class.create(hash)
+      else
+        update(hash)
+      end
+    end
+
     module BaseClassInterface
       extend T::Sig
       extend T::Helpers
@@ -33,6 +60,14 @@ module Kirei
       def where(hash)
       end
 
+      sig { abstract.params(hash: T.untyped).returns(T.untyped) }
+      def create(hash)
+      end
+
+      sig { abstract.params(attributes: T.untyped).void }
+      def wrap_jsonb_non_primivitives!(attributes)
+      end
+
       sig { abstract.params(hash: T.untyped).returns(T.untyped) }
       def resolve(hash)
       end
@@ -62,9 +97,16 @@ module Kirei
 
       include BaseClassInterface
 
+      # defaults to a pluralized, underscored version of the class name
       sig { override.returns(String) }
       def table_name
-        T.must(name.split("::").last).pluralize.underscore
+        @table_name ||= T.let(
+          begin
+            table_name_ = Kirei::Helpers.underscore(T.must(name.split("::").last))
+            "#{table_name_}s"
+          end,
+          T.nilable(String),
+        )
       end
 
       sig { override.returns(Sequel::Dataset) }
@@ -81,6 +123,49 @@ module Kirei
         resolve(db.where(hash))
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # default values defined in the model are used, if omitted in the hash
+      sig do
+        override.params(
+          hash: T::Hash[Symbol, T.untyped],
+        ).returns(T.attached_class)
+      end
+      def create(hash)
+        # instantiate a new object to ensure we use default values defined in the model
+        without_id = !hash.key?(:id)
+        hash[:id] = "kirei-fake-id" if without_id
+        new_record = from_hash(Helpers.deep_stringify_keys(hash))
+        all_attributes = T.let(new_record.serialize, T::Hash[String, T.untyped])
+        all_attributes.delete("id") if without_id && all_attributes["id"] == "kirei-fake-id"
+
+        wrap_jsonb_non_primivitives!(all_attributes)
+
+        if new_record.respond_to?(:created_at) && all_attributes["created_at"].nil?
+          all_attributes["created_at"] = Time.now.utc
+        end
+        if new_record.respond_to?(:updated_at) && all_attributes["updated_at"].nil?
+          all_attributes["updated_at"] = Time.now.utc
+        end
+
+        pkey = T.let(db.insert(all_attributes), String)
+
+        T.must(find_by({ id: pkey }))
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+      sig { override.params(attributes: T::Hash[T.any(Symbol, String), T.untyped]).void }
+      def wrap_jsonb_non_primivitives!(attributes)
+        # setting `@raw_db_connection.wrap_json_primitives = true`
+        # only works on JSON primitives, but not on blank hashes/arrays
+        return unless AppBase.config.db_extensions.include?(:pg_json)
+
+        attributes.each_pair do |key, value|
+          next unless value.is_a?(Hash) || value.is_a?(Array)
+
+          attributes[key] = T.unsafe(Sequel).pg_jsonb_wrap(value)
+        end
+      end
+
       sig do
         override.params(
           hash: T::Hash[Symbol, T.untyped],
@@ -106,7 +191,7 @@ module Kirei
 
         query.map do |row|
           row = T.cast(row, T::Hash[Symbol, T.untyped])
-          row.stringify_keys! # sequel returns symbolized keys
+          row.transform_keys!(&:to_s) # sequel returns symbolized keys
           from_hash(row, strict_loading)
         end
       end
@@ -118,7 +203,9 @@ module Kirei
         ).returns(T.nilable(T.attached_class))
       end
       def resolve_first(query, strict = nil)
-        resolve(query.limit(1), strict).first
+        strict_loading = strict.nil? ? AppBase.config.db_strict_type_resolving : strict
+
+        resolve(query.limit(1), strict_loading).first
       end
     end
 

data/lib/kirei/config.rb

@@ -17,16 +17,18 @@ module Kirei
 
     prop :logger, ::Logger, factory: -> { ::Logger.new($stdout) }
     prop :log_transformer, T.nilable(T.proc.params(msg: T::Hash[Symbol, T.untyped]).returns(T::Array[String]))
+    prop :log_default_metadata, T::Hash[Symbol, String], default: {}
+
     # dup to allow the user to extend the existing list of sensitive keys
     prop :sensitive_keys, T::Array[Regexp], factory: -> { SENSITIVE_KEYS.dup }
+
     prop :app_name, String, default: "kirei"
-    prop :db_url, T.nilable(String)
 
     # must use "pg_json" to parse jsonb columns to hashes
     #
     # Source: https://github.com/jeremyevans/sequel/blob/5.75.0/lib/sequel/extensions/pg_json.rb
     prop :db_extensions, T::Array[Symbol], default: %i[pg_json pg_array]
-
+    prop :db_url, T.nilable(String)
     # Extra or unknown properties present in the Hash do not raise exceptions at runtime
     # unless the optional strict argument to from_hash is passed
     #

data/lib/kirei/helpers.rb

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Kirei
+  module Helpers
+    class << self
+      extend T::Sig
+
+      # Simplified version from Rails' ActiveSupport::Inflector#underscore
+      sig { params(string: String).returns(String) }
+      def underscore(string)
+        string.gsub!(/([A-Z])(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) do
+          T.must((::Regexp.last_match(1) || ::Regexp.last_match(2))) << "_"
+        end
+        string.tr!("-", "_")
+        string.downcase!
+        string
+      end
+
+      # Simplified version from Rails' ActiveSupport
+      sig { params(string: T.any(String, Symbol)).returns(T::Boolean) }
+      def blank?(string)
+        string.nil? || string.to_s.empty?
+      end
+
+      sig { params(object: T.untyped).returns(T.untyped) }
+      def deep_stringify_keys(object)
+        deep_transform_keys(object) { _1.to_s rescue _1 } # rubocop:disable Style/RescueModifier
+      end
+
+      sig { params(object: T.untyped).returns(T.untyped) }
+      def deep_stringify_keys!(object)
+        deep_transform_keys!(object) { _1.to_s rescue _1 } # rubocop:disable Style/RescueModifier
+      end
+
+      sig { params(object: T.untyped).returns(T.untyped) }
+      def deep_symbolize_keys(object)
+        deep_transform_keys(object) { _1.to_sym rescue _1 } # rubocop:disable Style/RescueModifier
+      end
+
+      sig { params(object: T.untyped).returns(T.untyped) }
+      def deep_symbolize_keys!(object)
+        deep_transform_keys!(object) { _1.to_sym rescue _1 } # rubocop:disable Style/RescueModifier
+      end
+
+      # Simplified version from Rails' ActiveSupport
+      sig do
+        params(
+          object: T.untyped, # could be anything due to recursive calls
+          block: Proc,
+        ).returns(T.untyped) # could be anything due to recursive calls
+      end
+      private def deep_transform_keys(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[yield(key)] = deep_transform_keys(value, &block)
+          end
+        when Array
+          object.map { |e| deep_transform_keys(e, &block) }
+        else
+          object
+        end
+      end
+
+      sig do
+        params(
+          object: T.untyped, # could be anything due to recursive calls
+          block: Proc,
+        ).returns(T.untyped) # could be anything due to recursive calls
+      end
+      private def deep_transform_keys!(object, &block)
+        case object
+        when Hash
+          # using `each_key` results in a `RuntimeError: can't add a new key into hash during iteration`
+          # which is, because the receiver here does not necessarily have a `Hash` type
+          object.keys.each do |key| # rubocop:disable Style/HashEachMethods
+            value = object.delete(key)
+            object[yield(key)] = deep_transform_keys!(value, &block)
+          end
+          object
+        when Array
+          object.map! { |e| deep_transform_keys!(e, &block) }
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/kirei/logger.rb

@@ -17,12 +17,12 @@ module Kirei
   #
   # You can define a custom log transformer to transform the logline:
   #
-  #    Kirei.config.log_transformer = Proc.new { _1 }
+  #    Kirei::AppBase.config.log_transformer = Proc.new { _1 }
   #
-  # By default, "meta" is flattened, and sensitive values are masked using see `Kirei.config.sensitive_keys`.
+  # By default, "meta" is flattened, and sensitive values are masked using see `Kirei::AppBase.config.sensitive_keys`.
   # You can also build on top of the provided log transformer:
   #
-  #   Kirei.config.log_transformer = Proc.new do |meta|
+  #   Kirei::AppBase.config.log_transformer = Proc.new do |meta|
   #      flattened_meta = Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta)
   #      # Do something with the flattened meta
   #      flattened_meta.map { _1.to_json }
@@ -83,7 +83,16 @@ module Kirei
       ).void
     end
     def call(level:, label:, meta: {})
+      Kirei::AppBase.config.log_default_metadata.each_pair do |key, value|
+        meta[key] ||= value
+      end
+
+      #
+      # key names follow OpenTelemetry Semantic Conventions
+      # Source: https://opentelemetry.io/docs/concepts/semantic-conventions/
+      #
       meta[:"service.instance.id"] ||= Thread.current[:request_id]
+      meta[:"service.name"] ||= Kirei::AppBase.config.app_name
 
       # The Ruby logger only accepts one string as the only argument
       @queue << { level: level, label: label, meta: meta }
@@ -98,7 +107,7 @@ module Kirei
           label = log_data.fetch(:label)
           meta = T.let(log_data.fetch(:meta), T::Hash[Symbol, T.untyped])
           meta[:"service.version"] ||= Kirei::AppBase.version
-          meta[:timestamp] ||= Time.current.utc.iso8601
+          meta[:timestamp] ||= Time.now.utc.iso8601
           meta[:level] ||= level.to_s.upcase
           meta[:label] ||= label
 
@@ -107,7 +116,10 @@ module Kirei
           loglines = if log_transformer
             log_transformer.call(meta)
           else
-            [Oj.dump(Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta))]
+            [Oj.dump(
+              Kirei::Logger.flatten_hash_and_mask_sensitive_values(meta),
+              Kirei::OJ_OPTIONS,
+            )]
           end
 
           loglines.each { Kirei::Logger.logger.error(_1) }
@@ -131,19 +143,24 @@ module Kirei
 
     sig do
       params(
-        hash: T::Hash[Symbol, T.untyped],
+        hash: T::Hash[T.any(Symbol, String), T.untyped],
         prefix: Symbol,
       ).returns(T::Hash[Symbol, T.untyped])
     end
     def self.flatten_hash_and_mask_sensitive_values(hash, prefix = :'')
       result = T.let({}, T::Hash[Symbol, T.untyped])
-      hash.deep_symbolize_keys!
+      Kirei::Helpers.deep_symbolize_keys!(hash)
+      hash = T.cast(hash, T::Hash[Symbol, T.untyped])
 
       hash.each do |key, value|
-        new_prefix = prefix.blank? ? key : :"#{prefix}.#{key}"
+        new_prefix = Kirei::Helpers.blank?(prefix) ? key : :"#{prefix}.#{key}"
 
         case value
-        when Hash then result.merge!(flatten_hash_and_mask_sensitive_values(value.symbolize_keys, new_prefix))
+        when Hash
+          # Some libraries have a custom Hash class that inhert from Hash, but act differently, e.g. OmniAuth::AuthHash.
+          # This results in `transform_keys` being available but without any effect.
+          value = value.to_h if value.class != Hash
+          result.merge!(flatten_hash_and_mask_sensitive_values(value.transform_keys(&:to_sym), new_prefix))
         when Array
           value.each_with_index do |element, index|
             if element.is_a?(Hash) || element.is_a?(Array)
@@ -158,7 +175,9 @@ module Kirei
           if value.respond_to?(:serialize)
             serialized_value = value.serialize
             if serialized_value.is_a?(Hash)
-              result.merge!(flatten_hash_and_mask_sensitive_values(serialized_value.symbolize_keys, new_prefix))
+              result.merge!(
+                flatten_hash_and_mask_sensitive_values(serialized_value.transform_keys(&:to_sym), new_prefix),
+              )
             else
               result[new_prefix] = serialized_value&.to_s
             end

data/lib/kirei/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Kirei
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/kirei.rb

@@ -1,13 +1,22 @@
 # typed: strict
 # frozen_string_literal: true
 
-puts "Booting Kirei..." # rubocop:disable all
-
 require "boot"
 
 module Kirei
   extend T::Sig
 
+  # we don't know what Oj does under the hood with the options hash, so don't freeze it
+  # rubocop:disable Style/MutableConstant
+  OJ_OPTIONS = T.let(
+    {
+      mode: :compat, # required to dump hashes with symbol-keys
+      symbol_keys: false, # T::Struct.new works only with string-keys
+    },
+    T::Hash[Symbol, T.untyped],
+  )
+  # rubocop:enable Style/MutableConstant
+
   GEM_ROOT = T.let(
     Gem::Specification.find_by_name("kirei").gem_dir,
     String,
@@ -33,4 +42,4 @@ end
 
 Kirei.configure(&:itself)
 
-puts "Kirei (#{Kirei::VERSION}) booted!" # rubocop:disable all
+Kirei::Logger.logger.info("Kirei (#{Kirei::VERSION}) booted successfully!")

data/sorbet/rbi/shims/base_model.rbi

@@ -3,6 +3,9 @@
 # rubocop:disable Style/EmptyMethod
 module Kirei
   module BaseModel
+    include Kernel # "self" is a class since we include the module in a class
+    include T::Props::Serializable
+
     sig { returns(T.any(String, Integer)) }
     def id; end
 
@@ -12,6 +15,10 @@ module Kirei
       sig { returns(String) }
       def name; end
     end
+
+    module BaseClassInterface
+      # include T::Props::Serializable::ClassMethods
+    end
   end
 end
 # rubocop:enable Style/EmptyMethod

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: kirei
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Ludwig Reinmiedl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-29 00:00:00.000000000 Z
+date: 2024-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: puma
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
@@ -165,8 +137,10 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 description: |
-  Kirei's structure und developer experience is inspired by Rails, but it's not a Rails clone.
-  It's a framework that's built from the ground up to be strictly typed, performant and scaleable.
+  Kirei is a strictly typed Ruby micro/REST-framework for building scaleable and performant microservices.
+  It is built from the ground up to be clean and easy to use.
+  Kirei is based on Sequel as an ORM, Sorbet for typing, and Sinatra for routing.
+  It strives to have zero magic and to be as explicit as possible.
 email:
 - lud@reinmiedl.com
 - oss@dbl.works
@@ -193,9 +167,9 @@ files:
 - lib/kirei/base_controller.rb
 - lib/kirei/base_model.rb
 - lib/kirei/config.rb
+- lib/kirei/helpers.rb
 - lib/kirei/logger.rb
 - lib/kirei/version.rb
-- sorbet/rbi/dsl/active_support/callbacks.rbi
 - sorbet/rbi/shims/base_model.rbi
 homepage: https://github.com/swiknaba/kirei
 licenses:
@@ -222,5 +196,5 @@ rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Kirei is a strictly typed Ruby micro/REST-framework for building scaleable
-  and performant APIs.
+  and performant microservices.
 test_files: []

data/sorbet/rbi/dsl/active_support/callbacks.rbi

@@ -1,22 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for dynamic methods in `ActiveSupport::Callbacks`.
-# Please instead update this file by running `bin/tapioca dsl ActiveSupport::Callbacks`.
-
-module ActiveSupport::Callbacks
-  include GeneratedInstanceMethods
-
-  mixes_in_class_methods GeneratedClassMethods
-
-  module GeneratedClassMethods
-    def __callbacks; end
-    def __callbacks=(value); end
-    def __callbacks?; end
-  end
-
-  module GeneratedInstanceMethods
-    def __callbacks; end
-    def __callbacks?; end
-  end
-end