tcepsni 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c7e2dad3ee934784b32e2263cfd23a6a478ec4d648b7e02f1a02267238296e5
-  data.tar.gz: 5db7c50e53eea93481004efd7d2f359db19fe8099356bfd980564f3b861d52d1
+  metadata.gz: 93737301f5ec57317f38a815c3f51d40c2227668290e3baa6b642ffd82fb2396
+  data.tar.gz: ede377edc499d3469a7fbf6d2c5bea2e2e88568821c71cd5c4de937d72b20d7d
 SHA512:
-  metadata.gz: fc943477c66e694f76a6711ec01a2f82893c756fe7e30b1f00e8ef82d04c63699899b28252e2d046d148af68195a049bf2ca79b8b90bde359474ac610d9d3804
-  data.tar.gz: 8daf45aa53eb860b306357831c0c86a17d0e847fba6cfa8a051fe932a6d355ccfee936aee3ef48949b05a418013b7e140ce37ff57108ae653f768c97359c2f94
+  metadata.gz: f2b2779e7457a92b0678b695c17922e9e21960aa812d9ddf940697a80184541f318f457dae3a437be3bff93ead01cc95c08bd7e0cc3dd49fab8d954bdb518abd
+  data.tar.gz: 3ccb55ba0d3906d0722b0e39d7c69c5888749eb606cf671255aa7c7226dabddc8deaf6b09176fa6171d2e163da3574235b9d44f220bd9960a44b13890ec420cc

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## Unreleased
 
+## 0.4.0 - 2024-08-04
+
+### Changed
+
+* `parse_string` now parses leading double quote
+* `parse_array` now parses leading bracket
+* `parse_hash` now parses leading brace
+* `parse_object` now consider vendors
+* `parse_object`, `parse_integer`, `parse_expression`, and `parse_attributes` do not raise errors
+
+### Removed
+
+* `Tcepsni::Class#encoding?`
+
+### Added
+
+* Simple `Range` support and `parse_range`
+* `parse_float`
+* `parse_time`
+* `parse_attribute`
+* `parse_encoding`
+
+## 0.3.1 - 2024-07-21
+
+Update gemspec fields etc.
+There should be no API changes.
+
 ## 0.3.0 - 2023-11-18
 
 ### Changed

data/README.md

@@ -15,7 +15,7 @@ Tcepsni has a parsing method `Tcepsni.parse(str)`, which returns a parsed Ruby o
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.
-Then, run `rake test-unit` to run the tests.
+Then, run `rake test` to run the tests.
 You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`.
@@ -27,7 +27,7 @@ Bug reports and pull requests are welcome.
 
 ## License
 
-Copyright 2023 gemmaro.
+Copyright 2023, 2024 gemmaro.
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
 You may obtain a copy of the License at [Apache Software Foundation - Apache License, Version 2.0][asl].

data/lib/tcepsni/parser.rb

@@ -3,6 +3,8 @@ require 'forwardable'
 
 module Tcepsni
   class Parser
+    FAIL = Data.define
+
     def initialize(source, vendors:)
       @scanner = ::StringScanner.new(source)
       @vendors = vendors.flat_map { |vendor| [*vendor.dependencies, vendor] }.uniq
@@ -10,152 +12,224 @@ module Tcepsni
 
     # If it returned nil when failed, it collides with normal nil value.
     def parse_expression
-      if @scanner.skip(/nil\b/)
-        nil
-      elsif @scanner.skip(/true\b/)
-        true
-      elsif @scanner.skip(/false\b/)
-        false
-      elsif @scanner.skip(':')
-        parse_identifier
-      elsif @scanner.skip('"')
-        parse_string
-      elsif @scanner.skip('[')
-        parse_array
-      elsif @scanner.skip('{')
-        parse_hash
-      elsif @scanner.skip('#<')
-        pos = @scanner.pos
-        @vendors.select { |vendor| vendor.object? }.each do |vendor|
-          begin
-            @scanner.pos = pos
-            return vendor.parse(self)
-          rescue Error
-            next
-          end
-        end
-        @scanner.pos = pos
-        parse_object
-      else
-        if (digits = @scanner.scan(/\d+/))
-          int = Integer(digits)
-          if @scanner.skip('.')
-            int2 = parse_integer
-            Float("#{int}.#{int2}")
-          elsif digits.size == 4 && @scanner.skip(/-(?<month>[01]\d)-(?<day>\d\d) (?<hour>[012]\d):(?<minute>[0-5]\d):(?<second>[0-5]\d) (?<zone>[+-]\d\d\d\d)/)
-            Time.new(Integer(int), @scanner[:month], @scanner[:day],
-                     @scanner[:hour], @scanner[:minute], @scanner[:second],
-                     @scanner[:zone])
-          else
-            int
-          end
-        else
-          parse_class
-        end
-      end
+      FAIL == (expr = parse_nil)   or  return expr
+      FAIL == (expr = parse_false) or  return expr
+      (expr = (parse_true          or
+               parse_symbol        or
+               parse_string        or
+               parse_array         or
+               parse_hash          or
+               parse_encoding      or
+               parse_object        or
+               parse_range         or
+               parse_float         or
+               parse_time          or
+               parse_integer       or
+               parse_class))       and return expr
+      FAIL
     end
 
     alias parse parse_expression
 
+    def parse_nil
+      @scanner.skip(/nil\b/) or return FAIL
+      nil
+    end
+
+    def parse_true
+      @scanner.skip(/true\b/) and true
+    end
+
+    def parse_false
+      @scanner.skip(/false\b/) or return FAIL
+      false
+    end
+
     def parse_integer
-      int = @scanner.scan(/\d+/) or raise Error, 'no digits'
-      Integer(int)
+      @scanner.scan(/\d+/)&.to_i
     end
 
     def parse_identifier
-      id = @scanner.scan(/[A-Za-z_][A-Za-z0-9_]*/) or raise Error, 'no identifier'
-      id.intern
+      @scanner.scan(/[A-Za-z_][A-Za-z0-9_]*/)&.intern
     end
 
-    def parse_string
-      result = ''
-      until @scanner.eos?
-        if @scanner.skip('"')
-          return result
-        elsif @scanner.skip('\\"')
-          result << '"'
-        else
-          result << @scanner.getch
+    def parse_symbol
+      pos = @scanner.pos
+      @scanner.skip(':') and
+        begin
+          (id = parse_identifier) and return id
+          @scanner.skip('[]')     and return :[]
+          @scanner.pos = pos
+          return
         end
-      end
-      result
+    end
+
+    def parse_string
+      pos = @scanner.pos
+      @scanner.skip('"') or return
+      result = +''
+      result <<
+        if    @scanner.skip('"')   then return result
+        elsif @scanner.skip('\\"') then '"'
+        else                            @scanner.getch
+        end until @scanner.eos?
+      @scanner.pos = pos
+      nil
     end
 
     def parse_array
+      pos = @scanner.pos
+      @scanner.skip('[') or return
       result = []
       until @scanner.eos?
-        result << parse_expression rescue break
+        FAIL == (expr = parse_expression) and break
+        result << expr
         @scanner.skip(', ') or break
       end
-      @scanner.skip(']') or raise Error, "no array closer: #{@scanner.inspect}"
-      result
+      if @scanner.skip(']')
+        result
+      else
+        @scanner.pos = pos
+        nil
+      end
     end
 
     def parse_hash
+      pos = @scanner.pos
+      @scanner.skip('{') or return
       result = {}
       until @scanner.eos?
-        key = parse_expression rescue break
-        @scanner.skip('=>') or raise Error, 'no hash arrow'
-        value = parse_expression
+        FAIL == (key = parse_expression) and break
+        @scanner.skip('=>') and
+          FAIL != (value = parse_expression) or
+          begin
+            @scanner.pos = pos
+            return
+          end
         result[key] = value
         @scanner.skip(', ') or break
       end
-      @scanner.skip('}') or raise Error, 'no hash closer'
-      result
+      if @scanner.skip('}')
+        result
+      else
+        @scanner.pos = pos
+        return
+      end
     end
 
     def parse_class
-      namespaces = [parse_capitalized_identifier]
-      until @scanner.eos?
-        @scanner.skip('::') or break
-        @scanner.eos? and raise Error, 'incomplete class'
-        namespaces << parse_capitalized_identifier
-      end
+      pos = @scanner.pos
+      namespaces = [(parse_capitalized_identifier or return)]
+      namespaces <<
+        begin
+          parse_capitalized_identifier or
+            begin
+              @scanner.pos = pos
+              return
+            end
+        end while @scanner.skip('::')
       *namespaces, name = namespaces
-      Tcepsni::Class.new(name: name, namespaces: namespaces)
+      Tcepsni::Class.new(name:, namespaces:)
     end
 
     def parse_capitalized_identifier
-      id = @scanner.scan(/[A-Z][A-Za-z0-9_]*/) or raise Error, "no capitalized identifier: #{@scanner.inspect}"
-      id.intern
+      @scanner.scan(/[A-Z][A-Za-z0-9_]*/)&.intern
+    end
+
+    def parse_encoding
+      @scanner.skip(/#<Encoding:(?<name>[^>]+)>/) && Encoding.find(@scanner[:name])
     end
 
     def parse_object
-      klass = parse_class
-      if klass.encoding?
-        @scanner.skip(':') or raise Error, 'no colon separator in encoding object'
-        @scanner.skip(/(?<name>[^>]+)>/) or raise Error, 'invalid encoding name'
-        Encoding.find(@scanner[:name])
-      else
-        memory_reference = parse_memory_reference
-        attributes = parse_attributes
-        Tcepsni::Object.new(klass: klass, memory_reference: memory_reference, attributes: attributes)
+      pos = @scanner.pos
+      @scanner.skip('#<') or return
+      @vendors.select { |vendor| vendor.object? }.each do |vendor|
+        expr = vendor.parse(self) and return expr
       end
+
+      klass = parse_class                         and
+        memory_reference = parse_memory_reference and
+        attributes = parse_attributes             and
+        @scanner.skip('>')                        and
+        Tcepsni::Object.new(klass:, memory_reference:, attributes:) or
+        begin
+          @scanner.pos = pos
+          nil
+        end
+    end
+
+    def parse_attribute
+      pos = @scanner.pos
+      @scanner.skip('@') and
+        key = parse_identifier and
+        @scanner.skip('=') and
+        if FAIL == (value = parse_expression)
+          @scanner.pos = pos
+          return
+        else
+          return key, value
+        end
     end
 
     def parse_attributes
+      @scanner.match?('>') and return {}
+      pos = @scanner.pos
       attributes = {}
-      unless @scanner.skip('>')
-        until @scanner.eos?
-          @scanner.skip(' @') or break
-          key = parse_identifier
-          @scanner.skip('=') or raise Error, 'no attribute keyval equal char'
-          attributes[key.intern] = parse_expression
-          unless @scanner.skip(',')
-            @scanner.skip('>') or raise Error, "no object closer: #{@scanner.inspect}"
+      while @scanner.skip(' ')
+        key, value = (parse_attribute or return)
+        attributes[key] = value
+        @scanner.skip(',') or
+          if @scanner.match?('>')
             break
+          else
+            @scanner.pos = pos
+            return
           end
-        end
       end
       attributes
     end
 
     def parse_memory_reference
-      @scanner.skip(/:(?<memory_reference>0x[0-9a-f]{16})/) or raise Error, "no memory reference: #{@scanner.inspect}"
-      Integer(@scanner[:memory_reference])
+      @scanner.skip(/:(?<ref>0x[0-9a-f]{16})/) or return
+      Integer(@scanner[:ref])
+    end
+
+    def parse_range
+      pos = @scanner.pos
+      int = parse_integer and
+        if @scanner.skip("..") && (int2 = parse_integer)
+          int..int2
+        else
+          @scanner.pos = pos
+          nil
+        end
+    end
+
+    def parse_float
+      pos = @scanner.pos
+      int = parse_integer and
+        if @scanner.skip('.') && (int2 = parse_integer)
+          Float("#{int}.#{int2}")
+        else
+          @scanner.pos = pos
+          nil
+        end
+    end
+
+    def parse_time
+      pos = @scanner.pos
+      int = parse_integer and
+        if int <= 9999 && @scanner.skip(/-(?<month>[01]\d)-(?<day>\d\d) (?<hour>[012]\d):(?<minute>[0-5]\d):(?<second>[0-5]\d) (?<zone>[+-]\d\d\d\d)/)
+          Time.new(int, @scanner[:month], @scanner[:day],
+                   @scanner[:hour], @scanner[:minute], @scanner[:second],
+                   @scanner[:zone])
+        else
+          @scanner.pos = pos
+          nil
+        end
     end
 
     extend Forwardable
-    def_delegators :@scanner, :skip, :[]
+    def_delegators :@scanner, :skip, :[], :match?, :pos, :pos=
   end
 end

data/lib/tcepsni/vendor/activesupport/ordered_options.rb

@@ -5,13 +5,16 @@ module Tcepsni
     module ActiveSupport
       class OrderedOptions
         def self.parse(parser)
-          parser.skip('ActiveSupport::OrderedOptions {') or raise Error, 'no space between ActiveSupport::OrderedOptions class name and hash opener'
-          hash = parser.parse_hash
-          parser.skip('>') or raise Error, "no ActiveSupport ordered options closer: #{parser.scanner.inspect}"
+          pos = parser.pos
+          parser.skip('ActiveSupport::OrderedOptions ') and
+            hash = parser.parse_hash                    and
+            parser.skip('>') or
+            begin
+              parser.pos = pos
+              return
+            end
           options = ::ActiveSupport::OrderedOptions.new
-          hash.each do |key, val|
-            options[key] = val
-          end
+          hash.each { |key, val| options[key] = val }
           options
         end
 

data/lib/tcepsni/vendor/ipaddr.rb

@@ -4,8 +4,7 @@ module Tcepsni
   module Vendor
     class IPAddr
       def self.parse(parser)
-        parser.skip(/IPAddr: IPv[46]:(?<addr>[^>]+)>/) or raise Error, 'invalid IP address format error'
-        ::IPAddr.new(parser[:addr])
+        parser.skip(/IPAddr: IPv[46]:(?<addr>[^>]+)>/) && ::IPAddr.new(parser[:addr])
       end
 
       def self.object?

data/lib/tcepsni/vendor/pathname.rb

@@ -4,9 +4,7 @@ module Tcepsni
   module Vendor
     class Pathname
       def self.parse(parser)
-        parser.skip('Pathname:') or raise Error, 'no colon between Pathname class name and path string'
-        parser.skip(/(?<path>[^>]+)>/) or raise Error, 'invalid path string and closer'
-        ::Pathname.new(parser[:path])
+        parser.skip(/Pathname:(?<path>[^>]+)>/) && ::Pathname.new(parser[:path])
       end
 
       def self.object?

data/lib/tcepsni/vendor/rails/paths/root.rb

@@ -13,14 +13,21 @@ module Tcepsni
           end
 
           def self.parse(parser)
-            parser.skip('Rails::Paths::Root') or raise Error, 'this is not Rails::Paths::Root'
-            memory_reference = parser.parse_memory_reference
-            if parser.skip(' ...>')
-              attributes = {}
+            parser.skip('Rails::Paths::Root') or return
+            pos = parser.pos
+            if (memory_reference = parser.parse_memory_reference)
+              if parser.skip(' ...>')
+                Tcepsni::Vendor::Rails::Paths::Root.new(memory_reference, {})
+              elsif (attrs = parser.parse_attributes) && parser.skip('>')
+                Tcepsni::Vendor::Rails::Paths::Root.new(memory_reference, attrs)
+              else
+                parser.pos = pos
+                return
+              end
             else
-              attributes = parser.parse_attributes
+              parser.pos = pos
+              nil
             end
-            Tcepsni::Vendor::Rails::Paths::Root.new(memory_reference, attributes)
           end
 
           def self.object?

data/lib/tcepsni/vendor/string_scanner.rb

@@ -4,23 +4,28 @@ module Tcepsni
       attr_reader :pos, :total, :scanned, :rest
 
       def initialize(pos:, total:, scanned:, rest:)
-        @pos = pos
-        @total = total
+        @pos     = pos
+        @total   = total
         @scanned = scanned
-        @rest = rest
+        @rest    = rest
       end
 
       def self.parse(parser)
-        parser.skip('StringScanner ') or raise Error, 'no space after string scanner class name'
-        pos = parser.parse_integer
-        parser.skip('/') or raise Error, 'no string scanner progress delimiter slash'
-        total = parser.parse_integer
-        parser.skip(' "') or raise Error, 'no space after string scanner progress'
-        scanned = parser.parse_string
-        parser.skip(' @ "') or raise Error, "no string scanner mark in string: #{parser.scanner.inspect}"
-        rest = parser.parse_string
-        parser.skip('>') or raise Error, 'no string scanner closer'
-        Tcepsni::Vendor::StringScanner.new(pos: pos, total: total, scanned: scanned, rest: rest)
+        pos = parser.pos
+        parser.skip('StringScanner ')   and
+          pos = parser.parse_integer    and
+          parser.skip('/')              and
+          total = parser.parse_integer  and
+          parser.skip(' ')              and
+          scanned = parser.parse_string and
+          parser.skip(' @ ')            and
+          rest = parser.parse_string    and
+          parser.skip('>')              and
+          Tcepsni::Vendor::StringScanner.new(pos:, total:, scanned:, rest:) or
+          begin
+            parser.pos = pos
+            nil
+          end
       end
 
       def self.dependencies

data/lib/tcepsni/version.rb

@@ -1,3 +1,3 @@
 module Tcepsni
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/tcepsni.rb

@@ -2,10 +2,10 @@ require_relative 'tcepsni/version'
 require_relative 'tcepsni/parser'
 
 module Tcepsni
-  class Error < StandardError; end
+  Error = Class.new(StandardError)
 
   def self.parse(str, vendors: [])
-    Parser.new(str, vendors: vendors).parse
+    Parser.new(str, vendors:).parse
   end
 
   class Class
@@ -15,10 +15,6 @@ module Tcepsni
       @name = name
       @namespaces = namespaces
     end
-
-    def encoding?
-      @name == :Encoding && @namespaces.empty?
-    end
   end
 
   class Object

data/sig/tcepsni.gen.rbs

@@ -3,10 +3,12 @@
 # Classes
 module Tcepsni
   VERSION: String
+  Error: Class
 
 # def self.parse: (String str) -> untyped
 
   class Parser
+    FAIL: untyped
     extend Forwardable
     @scanner: StringScanner
     @vendors: Array[Array[untyped]]
@@ -24,6 +26,15 @@ module Tcepsni
   # def parse_object: -> Object
   # def parse_attributes: -> Hash[Symbol, untyped]
   # def parse_memory_reference: -> Integer
+  # def parse_nil: -> nil
+  # def parse_true: -> true?
+  # def parse_false: -> false
+  # def parse_symbol: -> Symbol
+  # def parse_range: -> Range?
+  # def parse_float: -> Float?
+  # def parse_time: -> Time?
+  # def parse_encoding: -> Encoding?
+  # def parse_attribute: -> [Symbol, untyped]?
   end
 
   class Class
@@ -48,47 +59,27 @@ module Tcepsni
 
   module Vendor
     class StringScanner
-      attr_reader pos: untyped
-      attr_reader total: untyped
-      attr_reader scanned: untyped
-      attr_reader rest: untyped
-      def initialize: (pos: untyped, total: untyped, scanned: untyped, rest: untyped) -> void
-      def self.parse: (untyped parser) -> StringScanner
-      def self.dependencies: -> Array[untyped]
-      def self.object?: -> true
+    # def initialize: (pos: untyped, total: untyped, scanned: untyped, rest: untyped) -> void
+    # def self.parse: (untyped parser) -> StringScanner?
+    # def self.dependencies: -> Array[untyped]
+    # def self.object?: -> true
+    # attr_reader pos: untyped
+    # attr_reader total: untyped
+    # attr_reader scanned: untyped
+    # attr_reader rest: untyped
     end
 
     module Rails
       module Paths
         class Root
-          attr_reader memory_reference: untyped
-          attr_reader attributes: Hash[untyped, untyped]
-          def initialize: (untyped memory_reference, Hash[untyped, untyped] attributes) -> void
-          def self.parse: (untyped parser) -> Root
-          def self.object?: -> true
-          def self.dependencies: -> [singleton(Pathname)]
+        # def initialize: (untyped memory_reference, Hash[untyped, untyped] attributes) -> void
+        # def self.parse: (untyped parser) -> Root?
+        # def self.object?: -> true
+        # def self.dependencies: -> [singleton(Pathname)]
+        # attr_reader memory_reference: untyped
+        # attr_reader attributes: Hash[untyped, untyped]
         end
       end
     end
-
-    module ActiveSupport
-      class OrderedOptions
-        def self.parse: (untyped parser) -> untyped
-        def self.dependencies: -> Array[untyped]
-        def self.object?: -> true
-      end
-    end
-
-    class IPAddr
-      def self.parse: (untyped parser) -> IPAddr
-      def self.object?: -> true
-      def self.dependencies: -> Array[untyped]
-    end
-
-    class Pathname
-      def self.parse: (untyped parser) -> Pathname
-      def self.object?: -> true
-      def self.dependencies: -> Array[untyped]
-    end
   end
 end

data/sig/tcepsni.rbs

@@ -1,12 +1,11 @@
 module Tcepsni
   VERSION: String
-
-  class Error < StandardError
-  end
+  Error: Class
 
   def self.parse: (String str) -> untyped
 
   class Parser
+    FAIL: untyped
     def initialize: (String source, vendors: Array[untyped]?) -> void
     def parse_expression: -> untyped
     alias parse parse_expression
@@ -20,6 +19,15 @@ module Tcepsni
     def parse_object: -> Object
     def parse_attributes: -> Hash[Symbol, untyped]
     def parse_memory_reference: -> Integer
+    def parse_nil: -> nil
+    def parse_true: -> true?
+    def parse_false: -> false
+    def parse_symbol: -> Symbol
+    def parse_range: -> Range?
+    def parse_float: -> Float?
+    def parse_time: -> Time?
+    def parse_encoding: -> Encoding?
+    def parse_attribute: -> [Symbol, untyped]?
   end
 
   class Class
@@ -44,24 +52,47 @@ module Tcepsni
 
   module Vendor
     class StringScanner
+      attr_reader pos: untyped
+      attr_reader total: untyped
+      attr_reader scanned: untyped
+      attr_reader rest: untyped
+      def initialize: (pos: untyped, total: untyped, scanned: untyped, rest: untyped) -> void
+      def self.parse: (untyped parser) -> StringScanner?
+      def self.dependencies: -> Array[untyped]
+      def self.object?: -> true
     end
 
     module Rails
       module Paths
         class Root
+          attr_reader memory_reference: untyped
+          attr_reader attributes: Hash[untyped, untyped]
+          def initialize: (untyped memory_reference, Hash[untyped, untyped] attributes) -> void
+          def self.parse: (untyped parser) -> Root?
+          def self.object?: -> true
+          def self.dependencies: -> [singleton(Pathname)]
         end
       end
     end
 
     module ActiveSupport
       class OrderedOptions
+        def self.parse: (untyped parser) -> nil
+        def self.dependencies: -> Array[untyped]
+        def self.object?: -> true
       end
     end
 
     class IPAddr
+      def self.parse: (untyped parser) -> IPAddr
+      def self.object?: -> true
+      def self.dependencies: -> Array[untyped]
     end
 
     class Pathname
+      def self.parse: (untyped parser) -> Pathname
+      def self.object?: -> true
+      def self.dependencies: -> Array[untyped]
     end
   end
 end

data/tcepsni.gemspec

@@ -9,10 +9,22 @@ Gem::Specification.new do |spec|
   spec.summary = 'inspected Ruby objects parser'
   spec.description = 'Tcepsni gem is a parser library for inspected strings of Ruby objects.'
   spec.license = 'Apache-2.0'
-  spec.required_ruby_version = '>= 3.1.0'
+
+  spec.homepage = 'https://codeberg.org/gemmaro/tcepsni'
+
+  spec.required_ruby_version = '>= 3.2'
 
   spec.files = Dir['lib/**/*.rb'] + Dir['sig/**/*.rbs'] +
                ['CHANGELOG.md', 'tcepsni.gemspec', 'README.md', 'LICENSE.txt']
   spec.require_paths = ['lib']
-  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.metadata = {
+    'rubygems_mfa_required' => 'true',
+    'bug_tracker_uri' => 'https://codeberg.org/gemmaro/tcepsni/issues',
+    'changelog_uri' => 'https://codeberg.org/gemmaro/tcepsni/src/branch/main/CHANGELOG.md',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/tcepsni',
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => spec.homepage,
+    'wiki_uri' => 'https://codeberg.org/gemmaro/tcepsni/wiki'
+  }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcepsni
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - gemmaro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-18 00:00:00.000000000 Z
+date: 2024-08-04 00:00:00.000000000 Z
 dependencies: []
 description: Tcepsni gem is a parser library for inspected strings of Ruby objects.
 email:
@@ -31,11 +31,17 @@ files:
 - sig/tcepsni.gen.rbs
 - sig/tcepsni.rbs
 - tcepsni.gemspec
-homepage:
+homepage: https://codeberg.org/gemmaro/tcepsni
 licenses:
 - Apache-2.0
 metadata:
   rubygems_mfa_required: 'true'
+  bug_tracker_uri: https://codeberg.org/gemmaro/tcepsni/issues
+  changelog_uri: https://codeberg.org/gemmaro/tcepsni/src/branch/main/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/tcepsni
+  homepage_uri: https://codeberg.org/gemmaro/tcepsni
+  source_code_uri: https://codeberg.org/gemmaro/tcepsni
+  wiki_uri: https://codeberg.org/gemmaro/tcepsni/wiki
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -44,14 +50,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: inspected Ruby objects parser