tapioca-compilers-dry_struct 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9dcbe2532639837d3887debbc6b919d0e6181ce40af168e8c0ef74ab1efdf21e
+  data.tar.gz: 81e38049ba86b21f99967514aa1bc9b6f87c60fa7a7d8b5d395633098b265d55
+SHA512:
+  metadata.gz: e0df50ffae3ca81b5236ecbb6c9d57b424841454067ffe5ce8f0d453b9e367706527f3940546b417f8055595bd13971cabef2a903f0c298bf28306935f1bbdeb
+  data.tar.gz: 5d2ba85b1a2399808f847407803c3b34a55dda5a474c6b766f836a432b05ff6289dc4f46ec75a2582b44ec3c2909595411d43406e6c0f26642d17fe5ad55bdf5

data/README.md

@@ -0,0 +1,66 @@
+**[WARNING] THIS APP IS ALPHA VERSION!!!**
+
+This script is a [Tapioca's custom DSL compiler](https://github.com/Shopify/tapioca#writing-custom-dsl-compilers) for [dry-struct](https://dry-rb.org/gems/dry-struct/main/).
+
+# References
+
+https://discourse.dry-rb.org/t/dry-rb-sorbet-can-we-unite/961
+
+https://github.com/Shopify/tapioca/issues/1210
+
+# Installation
+
+cp lib/tapioca/dsl/compilers/dry_struct.rb PATH_TO_YOUR_PROJECT/sorbet/tapioca/compilers/dry_struct.rb
+
+-----------------------------------
+
+Add this line to your application’s Gemfile:
+
+```
+gem 'tapioca-compilers-dry_struct'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+>  all the gem needs to do is to place the DSL compiler inside the lib/tapioca/dsl/compilers folder and it will be automatically discovered and loaded by Tapioca.
+>
+> https://github.com/Shopify/tapioca/blob/v0.10.2/README.md#writing-custom-dsl-compilers
+
+Tapioca automatically load the compiler inside gem, just you need to do is type a command below.
+
+```
+$ bundle exec tapioca dsl
+```
+
+# Development
+
+Execute `./bin/dsl` generates rbi files under `sorbet/rbi/dsl/`.
+If you need to test another dry-struct, add or edit rb files under `spec/examples/` and generate rbi files.
+
+A compiler itself exists in `lib/tapioca/dsl/compilers/dry_struct.rb`.
+
+# Test
+
+```
+bundle exec rake spec
+```
+
+# Environment Variables
+
+## DRY_PREFER_PLAIN_TIME
+
+\ | Ruby `Time` is typed as
+------- | --------
+0(DEFAULT) | `::ActiveSupport::TimeWithZone`
+1 | `::Time`
+
+## DRY_USE_EXPERIMENTAL_SHAPE
+
+\ | `Types::Hash.schema(name: Types::String, age: Types::Integer)` is typed as
+------- | --------
+0(DEFAULT) | `::T::Hash[::T.untyped, ::T.untyped]`
+1 | `{ name: ::String, age: ::Integer }`

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

@@ -0,0 +1,328 @@
+# typed: true
+# frozen_string_literal: true
+require 'dry-types'
+require 'dry-struct'
+begin
+  require 'dry-monads'
+rescue LoadError
+  # NOP
+end
+
+module Tapioca
+  module Compilers
+    # tapioca's [custom DSL compilers](https://github.com/Shopify/tapioca/blob/main/README.md#writing-custom-dsl-compilers)
+    # for [dry-struct](https://dry-rb.org/gems/dry-struct/).
+    class DryStruct < Tapioca::Dsl::Compiler
+      extend T::Sig
+
+      VERSION = '0.0.0'
+
+      # Convert Dry AST to type informations
+      #
+      # @example
+      # ```
+      # compiler = DryAstCompiler.new
+      # DryStructClass.schema.each do |s|
+      #   attribute_info = compiler.visit(s.to_ast)
+      #
+      #   # => { name: 'attr_name01', required: true, type: String }
+      #   # => { name: 'attr_name02', required: true, type: Integer }
+      #   # => { name: 'attr_name03', required: true, type: [String] }
+      #   # => { name: 'attr_name04', required: true, type: [[String]] }
+      #   # => { name: 'attr_name05', required: true, type: Hash }
+      #   # => { name: 'attr_name06', required: true, type: Date }
+      #   # => { name: 'attr_name07', required: true, type: DateTime }
+      #   # => { name: 'attr_name08', required: true, type: Time }
+      #   # => { name: 'attr_name09', required: true, type: Set }
+      #   # => { name: 'attr_name10', required: true, type: Range }
+      #   # => { name: 'attr_name11', required: true, type: YourKlass }
+      #   # => { name: 'attr_name12', required: true, type: #<DryAstCompiler::Undefined> }
+      #   # => { name: 'attr_name13', required: true, type: #<DryAstCompiler::Sum> }
+      #   # => { name: 'attr_name14', required: true, type: #<DryAstCompiler::Map> }
+      #   # => { name: 'attr_name15', required: true, type: #<DryAstCompiler::Schema> }
+      # do
+      # ```
+      class DryAstCompiler
+        # Represents dry's any type
+        class Undefined
+
+          def to_s
+            'Undefined'
+          end
+
+          def inspect
+            to_s
+          end
+        end
+
+        # Represents dry's sum type
+        class Sum
+          attr_reader :types
+
+          def initialize
+            @types = ::Set.new
+          end
+
+          def size
+            @types.size
+          end
+
+          def <<(arg)
+            if arg.is_a?(Sum)
+              arg.types.each { |t| @types << t }
+            else
+              @types << arg
+            end
+          end
+
+          def map(&block)
+            @types.map(&block)
+          end
+
+          def first
+            @types.first
+          end
+
+          def include_undefined?
+            @types.any? { |t| t.is_a?(Undefined) }
+          end
+
+          def include_nilclass?
+            @types.include?(::NilClass)
+          end
+
+          def delete_nilclass!
+            @types.reject! { |t| t == ::NilClass }
+          end
+
+          def to_s
+            "Sum(#{@types.map(&:to_s).join(',')})"
+          end
+
+          def inspect
+            to_s
+          end
+        end
+
+        # Represents dry's schema type
+        class Schema
+          def initialize(attribute_infos)
+            @attribute_infos = attribute_infos
+          end
+
+          def map(&block)
+            @attribute_infos.map(&block)
+          end
+
+          def empty?
+            @attribute_infos.empty?
+          end
+        end
+
+        # Represents dry's map type
+        class Map
+          attr_reader :key, :value
+
+          def initialize(key, value)
+            @key = key
+            @value = value
+          end
+        end
+
+        def visit(node)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest)
+        end
+
+        def visit_key(node)
+          name, required, rest = node
+          {
+            name: name,
+            required: required,
+            type: visit(rest)
+          }
+        end
+
+        def visit_constructor(node)
+          a, _ = node
+          visit(a)
+        end
+
+        def visit_struct(node)
+          type, _ = node
+          type
+        end
+
+        def visit_sum(node)
+          type = Sum.new
+          node.each do |n|
+            next if n.is_a?(::Hash)
+            type << visit(n)
+          end
+          type
+        end
+
+        def visit_and(node)
+          # NOP
+        end
+
+        def visit_array(node)
+          type = visit(node[0])
+          [type]
+        end
+
+        def visit_constrained(node)
+          types = node.map { |r| visit(r) }.reject(&:nil?)
+          types.size == 1 ? types[0] : types
+        end
+
+        def visit_nominal(node)
+          type, _option = node
+          type
+        end
+
+        def visit_predicate(_node)
+          # NOP
+        end
+
+        def visit_schema(node)
+          Schema.new(node[0].map { |n| visit(n) })
+        end
+
+        def visit_hash(_node)
+          ::Hash
+        end
+
+        def visit_map(node)
+          Map.new(visit(node[0]), visit(node[1]))
+        end
+
+        def visit_enum(node)
+          visit(node[0][1][0])
+        end
+
+        def visit_any(_node)
+          Undefined.new
+        end
+      end
+
+      ConstantType = type_member {{ fixed: ::T.class_of(::Dry::Struct) }}
+
+      sig { override.void }
+      def decorate
+        compiler = DryAstCompiler.new
+        root.create_path(constant) do |klass|
+          constant.schema.each do |s|
+            attribute_info = compiler.visit(s.to_ast)
+            if ::Dry::Types.const_defined?(:Maybe) && s.type.class == ::Dry::Types::Maybe
+              sorbet_type = '::T.any(::Dry::Monads::Maybe::Some, ::Dry::Monads::Maybe::None)'
+            else
+              sorbet_type = self.class.to_sorbet_type(attribute_info[:type], attribute_info[:required])
+            end
+            klass.create_method(
+              attribute_info[:name].to_s,
+              return_type: sorbet_type,
+            )
+          end
+        end
+      end
+
+      sig { override.returns(::T::Enumerable[Module]) }
+      def self.gather_constants
+        all_classes.select { |c| c < ::Dry::Struct }
+      end
+
+      sig { params(type: T.untyped, required: T::Boolean).returns(String) }
+      def self.to_sorbet_type(type, required)
+        base = if type.is_a?(DryAstCompiler::Sum)
+                 sum_to_sorbet_type(type)
+               elsif type.is_a?(DryAstCompiler::Schema)
+                 env('DRY_USE_EXPERIMENTAL_SHAPE') ? experimental_schema_to_sorbet_type(type) : '::T::Hash[::T.untyped, ::T.untyped]'
+               elsif type.is_a?(DryAstCompiler::Map)
+                 map_to_sorbet_type(type)
+               elsif type.is_a?(DryAstCompiler::Undefined)
+                 '::T.untyped'
+               elsif type.is_a?(::Array)
+                 "::T::Array[#{to_sorbet_type(type[0], true)}]"
+               elsif type == ::Hash
+                 '::T::Hash[::T.untyped, ::T.untyped]'
+               elsif type == ::Time
+                 env('DRY_PREFER_PLAIN_TIME') ? '::Time' : '::ActiveSupport::TimeWithZone'
+               elsif type == ::Range
+                 '::T::Range[::T.untyped]'
+               elsif type == ::Set
+                 '::T::Set[::T.untyped]'
+               elsif type == ::TrueClass || type == ::FalseClass
+                 '::T::Boolean'
+               elsif type.nil?
+                 '::NilClass'
+               else
+                 "::#{type.name}"
+               end
+        if base == '::T.untyped' || base == '::NilClass'
+          base
+        else
+          if required
+            base
+          else
+            if base.start_with?('::T.nilable')
+              base
+            else
+              "::T.nilable(#{base})"
+            end
+          end
+        end
+      end
+
+      sig { params(sum: DryAstCompiler::Sum).returns(String) }
+      def self.sum_to_sorbet_type(sum)
+        return '::T.untyped' if sum.include_undefined?
+
+        if sum.include_nilclass?
+          sum.delete_nilclass!
+          if sum.size < 2
+            "::T.nilable(#{to_sorbet_type(sum.first, true)})"
+          elsif (sum.types - [::TrueClass, ::FalseClass]).empty?
+            '::T.nilable(::T::Boolean)'
+          else
+            "::T.nilable(::T.any(#{sum.map { |t| to_sorbet_type(t, true) }.join(', ')}))"
+          end
+        else
+          if (sum.types - [::TrueClass, ::FalseClass]).empty?
+            '::T::Boolean'
+          elsif sum.size == 1
+            to_sorbet_type(sum.first, true)
+          else
+            "::T.any(#{sum.map { |t| to_sorbet_type(t, true) }.join(', ')})"
+          end
+        end
+      end
+
+      sig { params(map: DryAstCompiler::Map).returns(String) }
+      def self.map_to_sorbet_type(map)
+        "::T::Hash[#{map.key}, #{map.value}]"
+      end
+
+      sig { params(schema: DryAstCompiler::Schema).returns(String) }
+      def self.experimental_schema_to_sorbet_type(schema)
+        return '::T::Hash[::T.untyped, ::T.untyped]' if schema.empty?
+
+        sigs = schema.map do |i|
+          sorbet_type = to_sorbet_type(i[:type], i[:required])
+          i[:name].is_a?(::String) ? "'#{i[:name]}' => #{sorbet_type}" : "#{i[:name]}: #{sorbet_type}"
+        end
+
+        "{ #{sigs.join(', ')} }"
+      end
+
+      sig { params(key: String).returns(T::Boolean) }
+      def self.env(key)
+        v = ENV[key]
+        return false if v.nil?
+        return false if v == '0'
+        true
+      end
+    end
+  end
+end
+

data/tapioca-compilers-dry_struct.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name          = "tapioca-compilers-dry_struct"
+  spec.authors       = ["Yuki Jikumaru"]
+  spec.email         = ["jikumaruyuki@gmail.com"]
+  spec.license       = "MIT"
+  spec.version       = "0.0.0"
+
+  spec.summary       = "Tapioca's compiler for dry-struct"
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/YukiJikumaru/tapioca-compilers-dry_struct"
+  spec.files         = Dir["README.md", "CHANGELOG.md", "tapioca-compilers-dry_struct.gemspec", "lib/tapioca/dsl/compilers/dry_struct.rb"]
+  spec.require_paths = ["lib"]
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/YukiJikumaru/tapioca-compilers-dry_struct/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/YukiJikumaru/tapioca-compilers-dry_struct"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/YukiJikumaru/tapioca-compilers-dry_struct/issues"
+
+  spec.required_ruby_version = ">= 2.7.0"
+
+  # to update dependencies edit project.yml
+  spec.add_runtime_dependency "tapioca", ">= 0.10"
+  spec.add_runtime_dependency "dry-struct", ">= 1.2"
+  spec.add_runtime_dependency "dry-monads", ">= 1.2"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: tapioca-compilers-dry_struct
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Yuki Jikumaru
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !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: rake
+  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'
+description: Tapioca's compiler for dry-struct
+email:
+- jikumaruyuki@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/tapioca/dsl/compilers/dry_struct.rb
+- tapioca-compilers-dry_struct.gemspec
+homepage: https://github.com/YukiJikumaru/tapioca-compilers-dry_struct
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  changelog_uri: https://github.com/YukiJikumaru/tapioca-compilers-dry_struct/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/YukiJikumaru/tapioca-compilers-dry_struct
+  bug_tracker_uri: https://github.com/YukiJikumaru/tapioca-compilers-dry_struct/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Tapioca's compiler for dry-struct
+test_files: []