sorbet_typed-props 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b70c2c1612c8cbfff2f93f9693d3b13bc89be49a0d69defbec1d3b2692ddda1
-  data.tar.gz: d28ce15f689fb98809c098f812c7f38293fedb907c1bddcd2db3a2e7e8cce851
+  metadata.gz: e2b4406fdae5d3c123f3af9dbb6e3c8330fbb13dfa25aa047b010565971f7e84
+  data.tar.gz: e76a37ee0d36b57307c95a09f76befb494bbec6e3319eece03c80d22f9e6d3f2
 SHA512:
-  metadata.gz: 4ce011f262df5838a103bee1e54d683bb54eec14fe55f7492515c9f51c3d7c79d43d7244843f15eb6b6f4878477d730cb0213ee0d0bfa81570e4f7beed4d7fc5
-  data.tar.gz: 4de68b8e6d5d9486cad288ff1c05c4e8048512e5ca8c345c4cbc2e2b4d7fcb512a7f0da72a499a9585f32dd85d258f06ec9999a15f74b7a2246be5baa1b0294b
+  metadata.gz: f21a3d18b847cf6cbb6cca9ea453a1887c1dee87a9cd656408a1572bb6851a583bf078fe04f3c323e38d785ee0e8d6a0d572c5bf980735b4df33870166890551
+  data.tar.gz: 8351ee9a1af05ad8298b2a8b5ac7d1f46c98ea98d1df1de8a67d89d6f4afaa1019f3b6534ab3e772610146274fc0a5f4b475fcd3b43aa20482f6eec071fa2ba6

data/.cz.yaml

@@ -0,0 +1,20 @@
+---
+commitizen:
+  allowed_prefixes:
+    - fixup!
+    - squash!
+    - Merge
+    - Revert
+    - '[WIP]'
+  annotated_tag: true
+  name: cz_conventional_commits
+  pre_bump_hooks:
+    - mise x -- bundle install
+    - mise run update
+    - mise run format
+  tag_format: v$version
+  update_changelog_on_bump: true
+  version: 0.2.0
+  version_files:
+    - lib/sorbet_typed/props/version.rb
+  version_scheme: semver2

data/.pre-commit-config.yaml

@@ -0,0 +1,8 @@
+repos:
+  - hooks:
+      - id: commitizen
+      - id: commitizen-branch
+        stages:
+          - pre-push
+    repo: https://github.com/commitizen-tools/commitizen
+    rev: v4.9.1

data/.shellcheckrc.tmp

@@ -0,0 +1,14 @@
+# WIP: use this configuration
+
+disable=SC1091
+
+# spellchecker:ignore nullary
+enable=add-default-case
+enable=avoid-nullary-conditions
+enable=check-extra-masked-returns
+enable=check-set-e-suppressed
+enable=check-unassigned-uppercase
+enable=deprecate-which
+enable=quote-safe-variables
+enable=require-double-brackets
+enable=require-variable-braces

data/CHANGELOG.md

@@ -0,0 +1,54 @@
+## v0.2.0 (2025-11-05)
+
+### Feat
+
+- **renovate**: update CI matrix on lockFileMaintenance
+- **ci**: trigger renovate pipeline on default branch
+- **mise**: change default task output to "replacing"
+- **mise**: execute typecheck when running lint task
+- **renovate**: remove manual usage dependency declaration, as renovate seems to know it now
+- **renovate**: do postUpgradeTasks for lockfileMaintenance via mise and move update:appraisal task to file
+
+### Fix
+
+- **tapioca**: put optional params at end of signature, independent from their definition order
+- **ci**: adjust job rules
+- **sorbet**: robust tapioca dsl update/verification + removal of unused DSL RBIs
+- **sorbet**: exclude local gem from RBI generation
+- **renovate**: group ci ruby version matrix upgrades
+- **ci**: run ruby version matrix validation only for merge request events
+- **ci**: generate ruby version matrix only for versions with valid docker images
+- **appraisals**: make appraisal gem versions always deterministic by tracking lock files and update them via renovate
+  lockFileMaintenance
+- **coverage**: explicitly track all relevant ruby files, even if they don't get required
+- **ci**: make pipeline jobs interruptible by default to support canceling redundant pipelines
+- **ci**: check coverage when testing
+
+## v0.1.1 (2025-10-17)
+
+### Feat
+
+- **gem**: configure for publishing
+- **renovate, gemspec**: pin upper ruby version and manage with renovate
+- **ci**: don't version pin ruby images in CI matrix
+- **license**: add GPL v3 license
+- **ci**: test against multiple ruby versions
+- **renovate**: automatically update appraisals when updating gemspecs
+- **mise**: add formatting task
+- **ci**: add docker tag to use private runner
+- **props**: setup gemspec
+- **renovate**: group specific update types for bun and ruby
+- **props**: re-add, refactor and test tapioca compiler
+- **railway**: add first implementation mvp
+
+### Fix
+
+- **renovate**: use ruby as mise tool in ruby postUpgradeTasks
+- **renovate**: better ruby postUpgradeTask to ensure, updates actually run or at least fail instead of being suppressed
+- **renovate**: correctly run file update tasks after rubygems updates
+- **renovate**: correctly update mise versions in renovate.json
+- **renovate**: ensure correct postUpgradeTask execution
+- **dependencies**: move from appraisal to appraisal2
+- **mise**: do not install appraisal in test task, as it reformats the gemspecs
+- **renovate**: use correct docker tag to group bun updates
+- **renovate**: disable digest pinning for custom regex managers

data/README.md

@@ -9,9 +9,16 @@ class.
 This should make it easier to create classes with a set of attributes they should be initialized with. Inspiration was
 the
 [integration of literal properties into phlex](https://www.phlex.fun/miscellaneous/literal-properties.html#literal-properties),
-which doesn't really work with sorbet, if you want to have everything fully typed (and not use two runtime typesystems
+which doesn't really work with sorbet, if you want to have everything fully typed (and not use two runtime type-systems
 in parallel).
 
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Phlex Example](#phlex-example)
+  - [Method Visibility](#method-visibility)
+- [Development](#development)
+- [Contributing](#contributing)
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -43,6 +50,22 @@ my_object.my_prop # => "foo"
 my_object.my_prop = 'bar'
 ```
 
+### Phlex Example
+
+```ruby
+class Components::HelloWorld < Phlex::HTML
+  extend T::Sig
+  include SorbetTyped::Props
+
+  prop :name, String
+
+  sig { void }
+  def view_template
+    h1 { "Hello, #{name}!" }
+  end
+end
+```
+
 ### Method Visibility
 
 If you want attributes in your initializer but not be part of your public class interface, you can use ruby's visibility

data/lib/sorbet_typed/props/version.rb

@@ -1,8 +1,12 @@
 # typed: strict
 # frozen_string_literal: true
 
-module SorbetTyped # rubocop:disable Style/ClassAndModuleChildren -- Disabled, because this file gets required in gemspec, where zeitwerk is not active
+# :nocov: -- The file seems to get required before simplecov is started
+
+module SorbetTyped
   module Props
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end
+
+# :nocov:

data/lib/sorbet_typed/props.rb

@@ -4,15 +4,17 @@
 require 'sorbet-runtime'
 require_relative 'props/version'
 
-# an abstraction module to be included in any class to make the sorbet props
-# interface usable. It's just a wrapper around T::Props and
-# T::Props::Constructor. It's also the ancestor the custom tapioca compiler
-# looks for when generating initializer type annotation rbis.
-module SorbetTyped::Props
-  extend T::Helpers
+module SorbetTyped
+  # an abstraction module to be included in any class to make the sorbet props
+  # interface usable. It's just a wrapper around T::Props and
+  # T::Props::Constructor. It's also the ancestor the custom tapioca compiler
+  # looks for when generating initializer type annotation rbis.
+  module Props
+    extend T::Helpers
 
-  include T::Props
-  include T::Props::Constructor
+    include T::Props
+    include T::Props::Constructor
 
-  mixes_in_class_methods(T::Props::ClassMethods)
+    mixes_in_class_methods(T::Props::ClassMethods)
+  end
 end

data/lib/tapioca/dsl/compilers/sorbet_typed_props_constructor/prop_to_param_converter.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-module Tapioca # rubocop:disable Style/ClassAndModuleChildren
+module Tapioca
   module Dsl
     module Compilers
       class SorbetTypedPropsConstructor < Tapioca::Dsl::Compiler

data/lib/tapioca/dsl/compilers/sorbet_typed_props_constructor.rb

@@ -3,7 +3,7 @@
 
 require_relative 'sorbet_typed_props_constructor/prop_to_param_converter'
 
-module Tapioca # rubocop:disable Style/ClassAndModuleChildren
+module Tapioca
   module Dsl
     module Compilers
       # tapioca compiler generating rbi containing the initializer interface for a class using sorbet SorbetTyped::Props
@@ -63,12 +63,21 @@ module Tapioca # rubocop:disable Style/ClassAndModuleChildren
           root.create_path(constant) do |klass|
             klass.create_method(
               'initialize',
-              parameters: params,
+              parameters: params_with_optional_last(params:),
               return_type: 'void',
               comments: [RBI::Comment.new('Generated from sorbet SorbetTyped::Props')]
             )
           end
         end
+
+        sig { params(params: T::Array[RBI::TypedParam]).returns(T::Array[RBI::TypedParam]) }
+        def params_with_optional_last(params:)
+          required_params, optional_params = params.partition do |param|
+            param.param.is_a?(RBI::KwParam)
+          end
+
+          required_params + optional_params
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet_typed-props
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Richard Kramer
@@ -18,7 +18,7 @@ dependencies:
         version: '0.5'
     - - "<="
       - !ruby/object:Gem::Version
-        version: 0.6.12638
+        version: 0.6.12650
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
         version: '0.5'
     - - "<="
       - !ruby/object:Gem::Version
-        version: 0.6.12638
+        version: 0.6.12650
 - !ruby/object:Gem::Dependency
   name: tapioca
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +38,7 @@ dependencies:
         version: 0.16.11
     - - "<="
       - !ruby/object:Gem::Version
-        version: 0.17.7
+        version: 0.17.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -48,7 +48,7 @@ dependencies:
         version: 0.16.11
     - - "<="
       - !ruby/object:Gem::Version
-        version: 0.17.7
+        version: 0.17.9
 description: A small wrapper around sorbets T::Props and T::Props::Constructor. Also
   provides an accompanying tapioca compiler to allow using the prop-syntax in any
   class and getting the correct signature for an initializer.
@@ -58,16 +58,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".cz.yaml"
+- ".pre-commit-config.yaml"
+- ".shellcheckrc.tmp"
+- CHANGELOG.md
 - COPYING
 - README.md
 - lib/sorbet_typed/props.rb
 - lib/sorbet_typed/props/version.rb
-- lib/sorbet_typed/railway.rb.tmp
-- lib/sorbet_typed/railway.tmp/fail_fast.rb.tmp
-- lib/sorbet_typed/railway.tmp/railway.rb.tmp
-- lib/sorbet_typed/railway.tmp/version.rb.tmp
-- lib/sorbet_typed/railway.tmp/version_spec.rb.tmp
-- lib/sorbet_typed/railway_spec.rb.tmp
 - lib/tapioca/dsl/compilers/sorbet_typed_props_constructor.rb
 - lib/tapioca/dsl/compilers/sorbet_typed_props_constructor/prop_to_param_converter.rb
 homepage: https://gitlab.com/sorbet_typed/props

data/lib/sorbet_typed/railway.rb.tmp

@@ -1,9 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-require_relative 'railway/version'
-
-# This class provides a monad-style railway pattern, inspired by dry-monads do-syntax
-class SorbetTyped::Railway # rubocop:todo Lint/EmptyClass
-end

data/lib/sorbet_typed/railway.tmp/fail_fast.rb.tmp

@@ -1,16 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-class Typed::Monads::FailFast
-  extend T::Generic
-
-  Elem = type_member(:out)
-
-  sig { returns(Elem) }
-  attr_reader :value
-
-  sig { params(value: Elem).void }
-  def initialize(value)
-    @value = value
-  end
-end

data/lib/sorbet_typed/railway.tmp/railway.rb.tmp

@@ -1,259 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-# WIP: do we need https://sorbet.org/docs/exhaustiveness
-
-# WIP: move subclasses into own files
-
-# implementation of a sorbet-typed and -compatible monad-style short-circuit
-# pattern where you can run multiple steps, use their value OR let them return
-# early.
-#
-# Developed by @kramer and pending to be made open source under
-# https://gitlab.com/richardkramer/sorbet_typed. But for now we want to already
-# use the code, so everything already working is copied here.
-#
-# How to use:
-#
-
-# ```ruby
-# sig { returns(SuccessType, SorbetTyped::ShortCircuit::Shorted[ShortedType]))}
-# def do_something
-#   return SorbetTyped::ShortCircuit.short(info: shorted_value) if something_wrong?
-
-#   return SuccessType.new
-# end
-#
-# # this will return either the success type or a shorted result with the
-# # shorted type as `info`.
-# result = SorbetTyped::ShortCircuit[SuccessType, ShortedType].new.run do |circuit_breaker|
-#   foo = circuit_breaker.(do_something) # => will break early if do_something returns a circuit breaking result
-#   bar = circuit_breaker.(do_something_else(foo)) # => will break early if do_something_else(foo) returns a circuit breaking result
-
-#   do_another_thing(bar)
-# end
-# ```
-#
-# SuccessType and ShortedType might be anything you want. Just specify the types
-# when initializing the SorbetTyped::ShortCircuit instance.
-module SorbetTyped
-  class ShortCircuit
-    extend T::Generic
-
-    # The error thrown and handled within the run block to implement failing fast
-    # from any nesting depth
-    class CircuitShortedError < StandardError
-      extend T::Generic
-
-      FailureData = type_member(:out)
-
-      sig { returns(FailureData) }
-      attr_reader :failure
-
-      sig { params(failure: FailureData).void }
-      def initialize(failure:)
-        @failure = failure
-        super()
-      end
-    end
-
-    # Signal to fail fast. Info can be anything, e.g. an error object.
-    class Shorted
-      extend T::Generic
-
-      Elem = type_member(:out)
-
-      sig { returns(Elem) }
-      attr_reader :info
-
-      sig { params(info: Elem).void }
-      def initialize(info)
-        @info = info
-      end
-    end
-
-    # Callable implementing the logic to fail fast if the input is a Shorted
-    # signal. To be used like Dry::Monads `yield foo` syntax.
-    #
-    # Injected as parameter into a short circuit block, so you can use it directly.
-    class CircuitBreaker
-      extend T::Generic
-
-      Result = type_member
-
-      sig do
-        type_parameters(:U, :E).
-          params(result: T.all(T.type_parameter(:U), T.any(T.type_parameter(:E), Shorted[Result]))).
-          returns(T.type_parameter(:E))
-      end
-      def call(result)
-        case result
-        when Shorted
-          raise CircuitShortedError[T.type_parameter(:U)].new(failure: result)
-        else
-          result
-        end
-      end
-    end
-
-    SuccessResult = type_member
-    ShortedResult = type_member
-
-    sig do
-      type_parameters(:U).
-        params(info: T.type_parameter(:U)).
-        returns(Shorted[T.type_parameter(:U)])
-    end
-    def self.short(info:)
-      Shorted[T.type_parameter(:U)].new(info)
-    end
-
-    private
-
-    # Store if the last run failed fast
-    sig { returns(T::Boolean) }
-    attr_accessor :short_circuited
-
-    public
-
-    sig { void }
-    def initialize
-      @short_circuited = T.let(false, T::Boolean)
-    end
-
-    sig do
-      params(
-        _block:
-          T.proc.
-            params(fail_fast: CircuitBreaker[ShortedResult]).
-            returns(T.any(SuccessResult, Shorted[ShortedResult]))
-      ).
-        returns(T.any(SuccessResult, Shorted[ShortedResult]))
-    end
-    def run(&_block)
-      self.short_circuited = false
-      yield(CircuitBreaker[ShortedResult].new)
-    rescue CircuitShortedError => exception
-      self.short_circuited = true
-
-      # NOTE: sorbet is only able to detect
-      # `SorbetTyped::ShortCircuit::CircuitShortedError[T.anything]` in this rescue. But
-      # because it must come from `CircuitBreaker[ShortedResult]`, it will also
-      # always be `CircuitShortedError[SorbetTyped::ShortCircuit::Shorted[ShortedResult]]`. So we
-      # tell that to sorbet.
-      #
-      # NOTE: if one would manually throw this exception WITH A DIFFERENT failure
-      # data type, this would not raise, because generic types get erased at
-      # runtime. So just NEVER raise the CircuitShortedError error manually.
-      T.cast(exception, CircuitShortedError[SorbetTyped::ShortCircuit::Shorted[ShortedResult]]).failure
-    end
-
-    sig do
-      params(
-        block:
-          T.proc.
-            params(fail_fast: CircuitBreaker[ShortedResult]).
-            returns(T.any(SuccessResult, SorbetTyped::ShortCircuit::Shorted[ShortedResult]))
-      ).
-        returns(T.any(SuccessResult, ShortedResult))
-    end
-    def run_without_signal(&block)
-      result = run(&block)
-
-      case result
-      when SorbetTyped::ShortCircuit::Shorted
-        # NOTE: sorbet is only able to detect
-        # ```
-        #   T.all(
-        #     Typed::Monads::Shorted[T.anything],
-        #     T.any(
-        #       Typed::Monads::Shorted[Typed::Monads::ShortCircuit::ShortedResult],
-        #       Typed::Monads::ShortCircuit::SuccessResult
-        #     )
-        #   )
-        # ```
-        # , which leaves no other option
-        # than `Typed::Monads::Shorted[ShortedResult]`. So we tell that to the
-        # typechecker.
-        T.cast(result, SorbetTyped::ShortCircuit::Shorted[ShortedResult]).info
-      else
-        result
-      end
-    end
-
-    sig { returns(T::Boolean) }
-    def last_run_short_circuited?
-      short_circuited
-    end
-  end
-end
-
-#####################################################################################################################
-#####################################################################################################################
-#####################################################################################################################
-
-# An example class using above short circuit pattern. It's fully checked against
-# sorbet. You might comment it in and run `srb tc` to see the `T.reveal_type`
-# results in action.
-#
-# WIP: move to specs
-class SorbetTyped::ShortCircuitExample
-  extend T::Sig
-
-  sig { void }
-  def call
-    # Success Value might be Integer or String, Failure might be Symbol or Float
-    short_circuit = SorbetTyped::ShortCircuit[T.any(Integer, String), T.any(Symbol, Float)].new
-
-    result = short_circuit.run do |circuit_breaker|
-      T.reveal_type(circuit_breaker.(3)) # => Integer; sorbet knows the Input-Type would be the output type if it's not a Shorted signal
-
-      foo_var = circuit_breaker.(foo)
-
-      'bar'
-    end
-
-    short_circuit.last_run_short_circuited?
-    # => depends on the `[true, false].sample` below
-    #
-    # the `foo` call contains a shorted circuit, propagating the Shorted signal outwards and failing this circuit
-
-    T.reveal_type(result) # => T.any(Integer, String, SorbetTyped::Railway::Shorted[T.any(Symbol, Float)])
-
-    # the result might be any of the success type or the Shorted signal object
-    # with its shorted types. Use case...when logic to operate on the different
-    # return types.
-
-    if result.is_a? SorbetTyped::ShortCircuit::Shorted
-      T.reveal_type result # => SorbetTyped::Railway::Shorted[T.any(Symbol, Float)]
-      T.reveal_type result.info # => T.any(Symbol, Float); the for the railway defined shorted result types
-      puts result.info
-
-      # handle error
-      return
-    end
-
-    T.reveal_type(result)
-    # => T.any(Integer, String); sorbet statically knows, this can never be a shorted result, as we handled it before and return early
-  end
-
-  sig do
-    returns(T.any(Integer, SorbetTyped::ShortCircuit::Shorted[Symbol]))
-  end
-  def foo
-    SorbetTyped::ShortCircuit[Integer, Symbol].new.run do |circuit_breaker|
-      # this sometimes fast fails the short circuit and propagates the signal outwards
-      circuit_breaker.call validate # WIP: edge case where wrong typing does not raise errors in typechecker
-
-      42
-    end
-  end
-
-  sig { returns(T.any(NilClass, SorbetTyped::ShortCircuit::Shorted[Symbol])) }
-  def validate
-    return SorbetTyped::ShortCircuit.short(info: :foo) if [true, false].sample
-    return SorbetTyped::ShortCircuit.short(info: :bar) if [true, false].sample
-
-    SorbetTyped::ShortCircuit.short(info: :baz) if [true, false].sample
-  end
-end

data/lib/sorbet_typed/railway.tmp/version.rb.tmp

@@ -1,8 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module SorbetTyped # rubocop:disable Style/ClassAndModuleChildren -- Disabled, because this file gets required in gemspec, where zeitwerk is not active
-  class Railway
-    VERSION = '0.1.0'
-  end
-end

data/lib/sorbet_typed/railway.tmp/version_spec.rb.tmp

@@ -1,10 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-RSpec.describe SorbetTyped::Railway do # rubocop:disable RSpec/SpecFilePathFormat
-  let(:version) { SorbetTyped::Railway::VERSION }
-
-  it 'has a version number' do
-    expect(version).not_to be_nil
-  end
-end

data/lib/sorbet_typed/railway_spec.rb.tmp

@@ -1,5 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-RSpec.describe SorbetTyped::Railway do # rubocop:todo Lint/EmptyBlock, RSpec/EmptyExampleGroup
-end