uinit-structure 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3c8c42aab899fa0b64aa674b8096c9b1ed6be23e39643fd63d06f168876a18cd
+  data.tar.gz: 3499d5ba022a96ab76bf9aca62313787388271343caa2dbf5760997a972ebcc9
+SHA512:
+  metadata.gz: ca55bfc366a4b15b90c6306f7b5b724988e341ade9f2feaa38aa58c86335e4a89b214ce014e19af4e73d3d768c06a202f8a7e98345a011e8ac503c56f95a367b
+  data.tar.gz: 5c15f70a14a1b8ba09ab08302322e5bdb37c634110dfae0b27d77039ce13cd630d6a61ab1c5efb82e8e8ad6a8b9d86f8efbee83f64ea54e7103f53df9be31064

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Kimoja
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# Uinit::Structure
+
+Typed structure

data/lib/uinit/struct.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Uinit
+  class Struct
+    include Structure
+
+    struct {} # rubocop:disable Lint/EmptyBlock: Empty block detected
+
+    def initialize(**hsh)
+      initialize_structure!(hsh)
+    end
+  end
+end

data/lib/uinit/structure/attribute.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    # rubocop:disable Metrics/ClassLength
+    class Attribute
+      NAME_REGEX = /\A[A-Za-z]\w*\z/
+      UNDEFINED = Class.new.new.freeze
+
+      def initialize
+        @private_get = false
+        @private_set = false
+        @name = nil
+        @type = nil
+        @default = UNDEFINED
+        @struct = nil
+        @array_struct = false
+        @init = true
+        @get = nil
+        @set = nil
+        @as_json = true
+        @aliases = []
+      end
+
+      attr_accessor :default
+      attr_reader :private_get,
+                  :private_set,
+                  :name,
+                  :type,
+                  :struct,
+                  :array_struct,
+                  :init,
+                  :get,
+                  :set,
+                  :as_json,
+                  :aliases
+
+      def private_get=(val)
+        raise ArgumentError, 'private_get must be a boolean' unless [true, false].include?(val)
+
+        @private_get = val
+      end
+
+      def private_set=(val)
+        raise ArgumentError, 'private_set must be a boolean' unless [true, false].include?(val)
+
+        @private_set = val
+      end
+
+      def name=(val)
+        optional = val.to_s.end_with?('?')
+
+        if optional
+          self.default = nil if default == UNDEFINED
+          val = val.to_s.sub('?', '').to_sym
+        end
+
+        raise NameError, "Invalid attribute name '#{val}'" unless NAME_REGEX.match?(val)
+
+        @name = val
+      end
+
+      def type=(val)
+        val = Type.from(val)
+        raise ArgumentError, 'type must be a Type::Base' unless val.is_a?(Type::Base)
+        raise ArgumentError, 'Attribute cannot have a type and a struct at the same time' if struct
+
+        @type = val
+      end
+
+      def struct=(val)
+        raise ArgumentError, 'Attribute cannot have a type and a struct at the same time' if type
+
+        if val.is_a?(Class) && val < Struct
+          @struct = val
+          return
+        end
+
+        raise ArgumentError, 'struct must be a Struct Class or a Proc' unless val.is_a?(Proc)
+
+        @struct =
+          Class.new(Struct) do
+            struct(&val)
+          end
+      end
+
+      def array_struct=(val)
+        self.struct = val
+
+        @array_struct = true
+      end
+
+      def optional?
+        @default != UNDEFINED
+      end
+
+      def init=(val)
+        raise ArgumentError, 'init must be a boolean' unless [true, false].include?(val)
+
+        @init = val
+      end
+
+      def get=(val)
+        unless val.is_a?(Proc) || val.is_a?(Symbol)
+          raise ArgumentError,
+                '`get` must be a Proc or a Symbol'
+        end
+
+        @get = val
+      end
+
+      def set=(val)
+        unless val.is_a?(Proc) || val.is_a?(Symbol)
+          raise ArgumentError,
+                '`set` must be a Proc or a Symbol'
+        end
+
+        @set = val
+      end
+
+      def as_json=(val)
+        unless val.is_a?(Proc) || val.is_a?(Symbol) || val == false || val == true
+          raise ArgumentError,
+                '`as_json` must be a Proc or a Symbol or a Boolean'
+        end
+
+        @as_json = val
+      end
+
+      def aliases=(val)
+        val.each do |v|
+          raise NameError, "Invalid alias name '#{v}'" unless NAME_REGEX.match?(v)
+        end
+
+        @aliases = val
+      end
+
+      def as_json?
+        @as_json != false
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/uinit/structure/attribute_builder.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    class AttributeBuilder
+      def initialize(attribute = nil)
+        @attribute = attribute || Attribute.new
+      end
+
+      attr_accessor :attribute
+
+      def attr(name, type = nil, default = Attribute::UNDEFINED, &)
+        return build_mutliple(name, type, default, &) if name.is_a?(Array)
+
+        self.name(name)
+
+        build(type, default, &)
+      end
+
+      def abstract(type = nil, default = Attribute::UNDEFINED, &)
+        build(type, default, &)
+      end
+
+      def private(*get_set)
+        if get_set.empty?
+          attribute.private_get = true
+          attribute.private_set = true
+        else
+          attribute.private_get = true if get_set.include?(:get)
+          attribute.private_set = true if get_set.include?(:set)
+        end
+
+        self
+      end
+
+      def name(val)
+        attribute.name = val
+
+        self
+      end
+
+      def type(val)
+        attribute.type = val
+
+        self
+      end
+
+      def struct(val = nil, &val_proc)
+        attribute.struct = val.nil? ? val_proc : val
+
+        self
+      end
+
+      def array_struct(val = nil, &val_proc)
+        attribute.array_struct = val.nil? ? val_proc : val
+
+        self
+      end
+
+      def default(val = nil, &val_proc)
+        attribute.default = val.nil? ? val_proc : val
+
+        self
+      end
+
+      def optional(val)
+        attribute.optional = val
+
+        self
+      end
+
+      def init(val)
+        attribute.init = val
+
+        self
+      end
+
+      def get(val = nil, &val_proc)
+        attribute.get = val.nil? ? val_proc : val
+
+        self
+      end
+
+      def set(val = nil, &val_proc)
+        attribute.set = val.nil? ? val_proc : val
+
+        self
+      end
+
+      def as_json(val = nil, &val_proc)
+        attribute.as_json = val.nil? ? val_proc : val
+
+        self
+      end
+
+      def alias(*aliases)
+        attribute.aliases = aliases
+
+        self
+      end
+
+      private
+
+      def build_mutliple(name, type, default, &)
+        name.map do |nm|
+          builder = AttributeBuilder.new(attribute.clone)
+          builder.attr(nm, type, default, &)
+        end
+      end
+
+      def build(type, default, &attr_builder)
+        self.type(type) unless type.nil?
+        self.default(default) unless default == Attribute::UNDEFINED
+
+        instance_eval(&attr_builder) if attr_builder
+
+        self
+      end
+    end
+  end
+end

data/lib/uinit/structure/attribute_context.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    module AttributeContext
+      include Memoizable
+      include Type::Context
+
+      def self.scope(&)
+        context = Class.new { include AttributeContext }.new
+        context.instance_eval(&)
+
+        context.attributes
+      end
+
+      memo def attributes = []
+
+      def private(att_or_get_set = nil, *)
+        return att_or_getset.private(:get, :set) if att_or_get_set.is_a?(AttributeBuilder)
+
+        builder = AttributeBuilder.new.private(*[att_or_get_set, *].compact)
+        attributes << builder.attribute
+
+        builder
+      end
+
+      def attr(...)
+        push_attribute(AttributeBuilder.new.attr(...))
+      end
+
+      def abstract(...)
+        push_attribute(AttributeBuilder.new.abstract(...))
+      end
+
+      def using(attribute_builder)
+        push_attribute(AttributeBuilder.new(attribute_builder.attribute))
+      end
+
+      private
+
+      def push_attribute(builder)
+        if builder.is_a?(Array)
+          attributes.push(*builder.map(&:attribute))
+        else
+          attributes << builder.attribute
+        end
+
+        builder
+      end
+    end
+  end
+end

data/lib/uinit/structure/attribute_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    class AttributeError < StandardError
+      def initialize(attribute, msg)
+        super(msg)
+
+        @attribute = attribute
+      end
+
+      attr_reader :attribute
+
+      def message
+        "Error on attribute '#{attribute.name}', detail:\n#{super}"
+      end
+    end
+  end
+end

data/lib/uinit/structure/attribute_type_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    class AttributeTypeError < StandardError
+      def initialize(attribute, type_error)
+        super()
+
+        @attribute = attribute
+        @type_error = type_error
+
+        set_backtrace(type_error.backtrace)
+      end
+
+      attr_reader :attribute, :type_error
+
+      def message
+        "Type error on attribute '#{attribute.name}', detail:\n#{type_error.message}"
+      end
+    end
+  end
+end

data/lib/uinit/structure/compilers/as_json.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    module Compilers
+      class AsJson < Base
+        def initialize(mod, schema)
+          super(mod)
+
+          @schema = schema
+          @attributes = schema.class.instance_methods(false).map { schema.send(_1) }
+        end
+
+        attr_reader :schema, :attributes
+
+        def compile
+          compile_method(<<~RUBY, __FILE__, __LINE__ + 1)
+            def as_json
+              #{compile_super}
+              #{compile_json_attributes * "\n"}
+              json
+            end
+          RUBY
+        end
+
+        private
+
+        def compile_super
+          unless schema.class.ancestors[1..].any? { _1 < Schema }
+            return <<~RUBY
+              json = {}
+            RUBY
+          end
+
+          <<~RUBY
+            json = super
+          RUBY
+        end
+
+        def compile_json_attributes
+          attributes.filter_map do |attribute|
+            compile_json_attribute(attribute)
+          end
+        end
+
+        def compile_json_attribute(attribute)
+          return unless attribute.as_json?
+
+          name = attribute.name
+
+          if attribute.struct
+            return compile_json_struct(name) unless attribute.array_struct
+
+            return compile_json_array_struct(name)
+          end
+
+          return compile_json_true(name) if attribute.as_json == true
+
+          return compile_json_sym(name, attribute.as_json) if attribute.as_json.is_a?(Symbol)
+
+          compile_json_proc(name)
+        end
+
+        def compile_json_struct(name)
+          <<~RUBY
+            json[:#{name}] = self.#{name}.nil? ? nil : self.#{name}.as_json
+          RUBY
+        end
+
+        def compile_json_array_struct(name)
+          <<~RUBY
+            json[:#{name}] = self.#{name}.nil? ? nil : self.#{name}.map(&:as_json)
+          RUBY
+        end
+
+        def compile_json_true(name)
+          <<~RUBY
+            json[:#{name}] = self.#{name}
+          RUBY
+        end
+
+        def compile_json_sym(name, sym)
+          <<~RUBY
+            json[:#{name}] = self.#{name}.#{sym}
+          RUBY
+        end
+
+        def compile_json_proc(name)
+          <<~RUBY
+            _structure_schema.#{name}.as_json.call(json, self.#{name}, :#{name})
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/uinit/structure/compilers/attribute.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    module Compilers
+      # rubocop:disable Metrics/ClassLength
+      class Attribute < Base
+        def initialize(mod, attribute)
+          super(mod)
+
+          @attribute = attribute
+        end
+
+        attr_reader :attribute
+
+        def compile
+          compile_getter
+          compile_predicate
+          compile_setter
+          compile_aliases
+        end
+
+        private
+
+        def compile_getter
+          compile_method(<<~RUBY, __FILE__, __LINE__ + 1)
+            #{vis(:get)}def #{attribute.name}
+              return #{compile_get}
+            end
+          RUBY
+        end
+
+        def compile_get
+          case attribute.get
+          when Symbol
+            <<~RUBY.strip
+              @#{attribute.name}.#{attribute.get}
+            RUBY
+          when Proc
+            <<~RUBY.strip
+              #{lookup(:get)}.call(@#{attribute.name})
+            RUBY
+          else
+            <<~RUBY.strip
+              @#{attribute.name}
+            RUBY
+          end
+        end
+
+        def compile_predicate
+          compile_method(<<~RUBY, __FILE__, __LINE__ + 1)
+            #{vis(:get)}def #{attribute.name}?; @#{attribute.name}.present? end
+          RUBY
+        end
+
+        def compile_setter
+          compile_method(<<~RUBY, __FILE__, __LINE__ + 1)
+            #{vis(:set)}def #{attribute.name}=(value)
+              #{compile_set}
+              #{compile_struct}
+              #{compile_array_struct}
+              #{compile_type}
+              @#{attribute.name} = value
+            end
+          RUBY
+        end
+
+        def compile_set
+          case attribute.set
+          when Symbol
+            <<~RUBY.strip
+              value = value.#{lookup(:set)}
+            RUBY
+          when Proc
+            <<~RUBY.strip
+              value = #{lookup(:set)}.call(value)
+            RUBY
+          else
+            ''
+          end
+        end
+
+        def compile_struct
+          return unless attribute.struct && !attribute.array_struct
+
+          compile_optional_check(<<~RUBY)
+            unless value.is_a?(#{lookup(:struct)})
+              unless value.is_a?(Hash)
+                binding.pry
+                raise AttributeError.new(#{lookup}, "no implicit conversion of \#{ value.class } into Hash")
+              end
+
+              value = #{lookup(:struct)}.new(**value)
+            end
+          RUBY
+        end
+
+        def compile_array_struct
+          return unless attribute.struct && attribute.array_struct
+
+          compile_optional_check(<<~RUBY)
+            unless value.is_a?(Array)
+              raise AttributeError.new(#{lookup}, "no implicit conversion of \#{ value.class } into Array")
+            end
+
+            struct = #{lookup(:struct)}
+
+            value = value.map do |val|
+              next val if val.is_a?(struct)
+
+              unless val.is_a?(Hash)
+                raise AttributeError.new(#{lookup}, "no implicit conversion of \#{ val.class } into Hash")
+              end
+
+              struct.new(**val)
+            end
+          RUBY
+        end
+
+        def compile_optional_check(code)
+          return code unless attribute.optional? && attribute.default.nil?
+
+          <<~RUBY
+            unless value.nil?
+              #{code}
+            end
+          RUBY
+        end
+
+        def compile_type
+          return unless attribute.type
+
+          <<~RUBY
+            begin
+              #{lookup(:type)}.is!(value)
+            rescue Type::Error => error
+              raise AttributeTypeError.new(#{lookup}, error)
+            end
+          RUBY
+        end
+
+        def compile_aliases
+          attribute.aliases.each do |alia|
+            compile_alias_get(alia)
+            compile_alias_predicate(alia)
+            compile_alias_set(alia)
+          end
+        end
+
+        def compile_alias_get(alia)
+          compile_method(<<~RUBY, __FILE__, __LINE__ + 1)
+            #{vis(:get)}def #{alia}
+              self.#{attribute.name}
+            end
+          RUBY
+        end
+
+        def compile_alias_predicate(alia)
+          compile_method(<<~RUBY, __FILE__, __LINE__ + 1)
+            #{vis(:get)}def #{alia}?
+              self.#{attribute.name}?
+            end
+          RUBY
+        end
+
+        def compile_alias_set(alia)
+          compile_method(<<~RUBY, __FILE__, __LINE__ + 1)
+            #{vis(:get)}def #{alia}=(value)
+              self.#{attribute.name} = value
+            end
+          RUBY
+        end
+
+        def vis(met)
+          if (met == :get && attribute.private_get) ||
+             (met == :set && attribute.private_set)
+            'private '
+          else
+            ''
+          end
+        end
+
+        def lookup(att = nil)
+          "_structure_schema.#{attribute.name}#{att ? ".#{att}" : ''}"
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/uinit/structure/compilers/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    module Compilers
+      class Base
+        def self.compile(...)
+          new(...).compile
+        end
+
+        def initialize(mod)
+          @mod = mod
+        end
+
+        attr_reader :mod
+
+        def compile_method(str, file, line)
+          mod.class_eval(str.gsub(/^$\s*\n/, '').gsub(/\s+$/, ''), file, line)
+        end
+      end
+    end
+  end
+end

data/lib/uinit/structure/compilers/constructor.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    module Compilers
+      class Constructor < Base
+        def initialize(mod, schema)
+          super(mod)
+
+          @schema = schema
+          @attributes = schema.class.instance_methods(false).map { schema.send(_1) }
+        end
+
+        attr_reader :schema, :attributes
+
+        def compile
+          compile_method(<<~RUBY, __FILE__, __LINE__ + 1)
+            def initialize_structure!(hsh)
+              #{compile_super}
+              #{compile_attribute_initializers * "\n"}
+            end
+          RUBY
+        end
+
+        private
+
+        def compile_super
+          return unless schema.class.ancestors[1..].any? do |ancestor|
+            ancestor < Schema
+          end
+
+          <<~RUBY
+            begin
+              super(hsh)
+            end
+          RUBY
+        end
+
+        def compile_attribute_initializers
+          attributes.filter_map do |attribute|
+            compile_attribute_initializer(attribute)
+          end
+        end
+
+        def compile_attribute_initializer(attribute)
+          name = attribute.name
+
+          unless attribute.init
+            return unless attribute.optional?
+
+            return compile_default_attribute(name, attribute)
+          end
+
+          return compile_non_optional_attribute(name) unless attribute.optional?
+
+          compile_optional_attribute(name, attribute)
+        end
+
+        def compile_non_optional_attribute(name)
+          <<~RUBY
+            raise ArgumentError, "'#{name}' must be defined" unless hsh.key?(:#{name})
+            self.#{name} = hsh[:#{name}]
+          RUBY
+        end
+
+        def compile_optional_attribute(name, attribute)
+          <<~RUBY
+            if hsh.key?(:#{name})
+              self.#{name} = hsh[:#{name}]
+            else
+              #{compile_default_attribute(name, attribute)}
+            end
+          RUBY
+        end
+
+        def compile_default_attribute(name, attribute)
+          <<~RUBY
+            self.#{name} = _structure_schema.#{name}.default#{attribute.default.is_a?(Proc) ? '.call' : ''}
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/uinit/structure/compilers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    module Compilers
+    end
+  end
+end

data/lib/uinit/structure/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Uinit
+  module Structure
+    VERSION = '0.1.0'
+  end
+end

data/lib/uinit/structure.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+require 'uinit/type'
+require 'uinit/memoizable'
+
+module Uinit; end
+
+Zeitwerk::Loader.for_gem.tap do |loader|
+  loader.push_dir(__dir__, namespace: Uinit)
+  loader.setup
+end
+
+module Uinit
+  module Structure
+    include Memoizable
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    class Schema; end
+
+    module ClassMethods
+      include Memoizable
+
+      memo def structure_schema
+        if respond_to?(:superclass) && superclass.respond_to?(:structure_schema)
+          return Class.new(superclass.structure_schema.class).new
+        end
+
+        Class.new(Schema).new
+      end
+
+      memo def structure_module
+        structure_module = Module.new
+
+        include structure_module
+
+        structure_module
+      end
+
+      def struct(&)
+        AttributeContext.scope(&).each do |attribute|
+          raise NameError, 'Attribute must have a name' unless attribute.name
+
+          structure_schema.class.define_method(attribute.name) { attribute }
+          Compilers::Attribute.compile(structure_module, attribute)
+        end
+
+        Compilers::Constructor.compile(structure_module, structure_schema)
+        Compilers::AsJson.compile(structure_module, structure_schema)
+      end
+    end
+
+    private
+
+    memo def _structure_schema = self.class.structure_schema
+  end
+end

data/uinit-structure.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'uinit/structure/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'uinit-structure'
+  spec.version = Uinit::Structure::VERSION
+  spec.authors = ['Kimoja']
+  spec.email = ['joakim.carrilho@cheerz.com']
+
+  spec.summary = 'Typed structure'
+  spec.description = 'Typed structure'
+  spec.homepage = 'https://github.com/Kimoja/uinit-structure'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.2.1'
+  spec.files = Dir['CHANGELOG.md', 'LICENSE.txt', 'README.md', 'uinit-structure.gemspec', 'lib/**/*']
+  spec.require_paths = ['lib']
+  spec.executables = []
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['source_code_uri'] = 'https://github.com/Kimoja/uinit-structure'
+  spec.metadata['changelog_uri'] = 'https://github.com/Kimoja/uinit-structure/blob/main/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/Kimoja/uinit-structure/issues'
+
+  spec.add_runtime_dependency 'zeitwerk', '~> 2.6'
+
+  spec.add_dependency 'uinit-memoizable', '~> 0.1.0'
+  spec.add_dependency 'uinit-type', '~> 0.1.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: uinit-structure
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kimoja
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: uinit-memoizable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: uinit-type
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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: Typed structure
+email:
+- joakim.carrilho@cheerz.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/uinit/struct.rb
+- lib/uinit/structure.rb
+- lib/uinit/structure/attribute.rb
+- lib/uinit/structure/attribute_builder.rb
+- lib/uinit/structure/attribute_context.rb
+- lib/uinit/structure/attribute_error.rb
+- lib/uinit/structure/attribute_type_error.rb
+- lib/uinit/structure/compilers.rb
+- lib/uinit/structure/compilers/as_json.rb
+- lib/uinit/structure/compilers/attribute.rb
+- lib/uinit/structure/compilers/base.rb
+- lib/uinit/structure/compilers/constructor.rb
+- lib/uinit/structure/version.rb
+- uinit-structure.gemspec
+homepage: https://github.com/Kimoja/uinit-structure
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Kimoja/uinit-structure
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/Kimoja/uinit-structure
+  changelog_uri: https://github.com/Kimoja/uinit-structure/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/Kimoja/uinit-structure/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: Typed structure
+test_files: []