lowtype 1.4.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd21f076ae997541e19b4bd3d405d434a7a3395165afa5084dbe7e2701d591a7
-  data.tar.gz: ab3cc40ff0baef867751c9a0c5660cb6340951167c677ab7c4412b389e49f394
+  metadata.gz: e86b8beb0266fbdc8746e0b9db1be9e6bd1d5da302d3120da506f61ad91954d3
+  data.tar.gz: 03f88ef3894d97035083dfd24c84e570e457272662c50ece98ebb3611d68579f
 SHA512:
-  metadata.gz: 906c8a132cbddaf7b907b7933f4a8fe9686c47dad2ad5811c49be40637c8ce4cb63efd88bcb602255610addf80b57421fdde95b5919e5708e5931994a3575c8f
-  data.tar.gz: 2e7f57855d2e290a2bc353470bec98af3bbf24550006de66ae265de3ecd99623a75874e47ce57bf9667ecf8efaad843a4d173c219222c35067c52002e50e5a05
+  metadata.gz: bf55ecfffdf71788a602ede14078a87c1d216700d24317698b23840045e6fe546af705791db67b575ce4467df35c9e98d4cda8a588a27c404e5e604a30d7a677
+  data.tar.gz: 3235f927017e31e58b71a303639adaf0b721a354a1442d6f125d9fe270eae269bb6967bf08d1ab7687ea99f5bfc9ca0a27b74095ec50154fc8e95a0ad7198077

data/lib/cli/cli.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'trees'
+
+require_relative 'rbs/exporter'
+require_relative 'type_stripper'
+
+module LowType
+  module CLI
+    extend Trees
+
+    line('rbs :src') do |src|
+      s { 'Exports files from the source to type signatures in the sig directory' }
+      e { 'lowtype rbs app' }
+      x { RBS::Exporter.export(path: src) }
+
+      line('--boot', '-b') do |src, boot|
+        s { 'Runs a file before export and could be used to load constants outside your source directory' }
+        e { 'lowtype rbs app --boot config/boot.rb' }
+        x { RBS::Exporter.export(path: src, boot:) }
+      end
+    end
+
+    line('strip!') do
+      s { 'Strips files from the current directory of their types' }
+      e { 'lowtype strip' }
+      x { TypeStripper.export(src: '.', dest: '.') }
+    end
+
+    line('strip :src :dest') do |src, dest|
+      s { 'Exports files from the source directory to a destination directory with types stripped' }
+      e { 'lowtype strip src/app dest/app' }
+      x { TypeStripper.export(src:, dest:) }
+    end
+  end
+end

data/lib/cli/rbs/class_sig.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'lowkey'
+
+require_relative 'method_sig'
+
+module LowType
+  module CLI
+    module RBS
+      module ClassSig
+        class << self
+          def build(class_proxy:, file_proxy:)
+            body = method_lines(class_proxy)
+            wrap_namespace(namespace: class_proxy.namespace, name: class_proxy.name, body:, file_proxy:).join("\n")
+          end
+
+          private
+
+          def method_lines(class_proxy)
+            instance_lines = class_proxy.instance_methods.each_value.map do |method_proxy|
+              MethodSig.build(method_proxy:)
+            end
+
+            class_lines = class_proxy.class_methods.each_value.map do |method_proxy|
+              MethodSig.build(method_proxy:, class_method: true)
+            end
+
+            instance_lines + class_lines
+          end
+
+          def wrap_namespace(namespace:, name:, body:, file_proxy:)
+            lines = wrap("class #{name}", body)
+
+            segments(namespace).reverse_each do |segment|
+              lines = wrap("#{namespace_type(segment:, file_proxy:)} #{segment}", lines)
+            end
+
+            lines
+          end
+
+          def wrap(header, body_lines)
+            [header, *body_lines.map { |line| "  #{line}" }, 'end']
+          end
+
+          # Lowkey's "namespace" includes the class's own name.
+          def segments(namespace)
+            namespace.split('::')[0..-2]
+          end
+
+          def namespace_type(segment:, file_proxy:)
+            file_proxy.definitions[segment].is_a?(::Lowkey::ClassProxy) ? 'class' : 'module'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/rbs/exporter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'lowkey'
+require 'dirload'
+
+require_relative 'class_sig'
+
+module LowType
+  module CLI
+    module RBS
+      class MissingPathError < StandardError; end
+
+      # Exports .rbs files for every class in `path` (a file or directory) that includes LowType.
+      # Uses dirload() to autoload missing constants from files within the same directory.
+      module Exporter
+        class << self
+          def export(path:, boot: nil)
+            dirload(path).loaded_paths.each do |file_path, _adapter|
+              next unless file_path.end_with?('.rb') || file_path.end_with?('.rbx')
+
+              export_file(file_path:)
+            end
+          end
+
+          private
+
+          def export_file(file_path:)
+            return unless file_proxy = ::Lowkey[file_path]
+
+            class_proxies = typed_class_proxies(file_proxy)
+            return if class_proxies.empty?
+
+            content = class_proxies.map do |class_proxy|
+              ClassSig.build(class_proxy:, file_proxy:)
+            end.join("\n\n")
+
+            save_file(file_path:, content:)
+          end
+
+          def typed_class_proxies(file_proxy)
+            file_proxy.definitions.values.filter do |proxy|
+              includes_lowtype = proxy.lines[proxy.start_line..proxy.end_line].find do |line|
+                line.include?('include LowType')
+              end
+
+              proxy.is_a?(::Lowkey::ClassProxy) && includes_lowtype
+            end
+          end
+
+          def save_file(file_path:, content:)
+            sig_path = sig_path(file_path:)
+            FileUtils.mkdir_p(File.dirname(sig_path))
+            File.write(sig_path, "#{content}\n")
+
+            puts "Exported #{sig_path}"
+          end
+
+          def sig_path(file_path:)
+            relative = file_path.delete_prefix("#{Dir.pwd}/").delete_prefix('lib/')
+            File.join('sig', relative.sub(/\.rb\z/, '.rbs'))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/rbs/expression_mapper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'type_mapper'
+
+module LowType
+  module CLI
+    module RBS
+      # Maps a TypeExpression to an RBS type.
+      module ExpressionMapper
+        class << self
+          def match(expression)
+            return 'untyped' if expression.nil?
+
+            types = expression.types.map { |type| TypeMapper.map(type) }.uniq
+            types = ['untyped'] if types.empty?
+
+            union = types.join(' | ')
+            nilable?(expression) ? nilable(union:, multiple: types.length > 1) : union
+          end
+
+          private
+
+          def nilable?(expression)
+            expression.default_value.nil?
+          end
+
+          def nilable(union:, multiple:)
+            multiple ? "(#{union})?" : "#{union}?"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/rbs/method_sig.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'expression_mapper'
+
+module LowType
+  module CLI
+    module RBS
+      # Builds an RBS method signature line from a Lowkey::MethodProxy.
+      # TODO: Support positional args, keyword args and blocks.
+      module MethodSig
+        POSITIONAL_TYPES = %i[pos_req pos_opt].freeze
+        KEYWORD_TYPES = %i[key_req key_opt].freeze
+
+        class << self
+          def build(method_proxy:, class_method: false)
+            scope = class_method ? 'self.' : ''
+            "def #{scope}#{method_proxy.name}: (#{params(method_proxy)}) -> #{return_type(method_proxy)}"
+          end
+
+          private
+
+          def params(method_proxy)
+            positional = method_proxy.params.select { |param| POSITIONAL_TYPES.include?(param.type) }
+            keyword = method_proxy.params.select { |param| KEYWORD_TYPES.include?(param.type) }
+
+            (positional.map { |param| positional_fragment(param) } + keyword.map { |param| keyword_fragment(param) }).join(', ')
+          end
+
+          def positional_fragment(param_proxy)
+            type = ExpressionMapper.match(param_proxy.expression)
+            optional?(param_proxy) ? "?#{type} #{param_proxy.name}" : "#{type} #{param_proxy.name}"
+          end
+
+          def keyword_fragment(param_proxy)
+            type = ExpressionMapper.match(param_proxy.expression)
+            optional?(param_proxy) ? "?#{param_proxy.name}: #{type}" : "#{param_proxy.name}: #{type}"
+          end
+
+          def optional?(param_proxy)
+            return !param_proxy.expression.required? if param_proxy.expression
+
+            %i[pos_opt key_opt].include?(param_proxy.type)
+          end
+
+          def return_type(method_proxy)
+            ExpressionMapper.match(method_proxy.return_proxy&.expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/rbs/type_mapper.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../../types/complex_types'
+
+module LowType
+  module CLI
+    module RBS
+      module TypeMapper
+        COMPLEX_TYPE_MAP = {
+          Low::Types::Boolean => 'bool',
+          Low::Types::HTML => 'String',
+          Low::Types::JSON => 'String',
+          Low::Types::XML => 'String',
+          Low::Types::Status => 'Integer',
+          Low::Types::Headers => 'Hash[String, untyped]',
+          Low::Types::Tuple => 'Array[untyped]'
+        }.freeze
+
+        class << self
+          def map(type)
+            return 'nil' if type == NilClass
+            return 'bool' if [TrueClass, FalseClass].include?(type)
+            return COMPLEX_TYPE_MAP[type] if COMPLEX_TYPE_MAP.key?(type)
+
+            case type
+            when ::Low::TypeExpression then map_expression(type)
+            when Array then map_array(type)
+            when Hash then map_hash(type)
+            when Class then map_class(type)
+            else 'untyped'
+            end
+          end
+
+          private
+
+          # A nested type expressio like "String | Integer" inside "Array[String | Integer]".
+          def map_expression(expression)
+            require_relative 'expression_mapper'
+            ExpressionMapper.match(expression)
+          end
+
+          # When [T] then every element is type T. When [X, Y, Z] then each element is that type at that position.
+          def map_array(type)
+            return 'Array[untyped]' if type.empty?
+            return "[#{type.map { |subtype| map(subtype) }.join(', ')}]" if type.length > 1
+
+            "Array[#{map(type.first)}]"
+          end
+
+          def map_hash(type)
+            return 'Hash[untyped, untyped]' if type.empty?
+
+            "Hash[#{map(type.keys.first)}, #{map(type.values.first)}]"
+          end
+
+          def map_class(type)
+            return 'untyped' if type.name.nil?
+
+            "::#{type.name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/type_stripper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LowType
+  module TypeStripper
+    module_function
+
+    def export(src:, dest:); end
+  end
+end

data/lib/expressions/type_expression.rb

@@ -7,9 +7,11 @@ require_relative '../proxies/param_proxy'
 require_relative '../queries/type_query'
 
 module Low
-  root_path = File.expand_path(__dir__)
-  adapter_paths = Dir.chdir(root_path) { Dir.glob('adapters/*') }.map { |path| File.join(root_path, path) }
-  module_paths = %w[expressions/expressions instance_types redefiner].map { |path| File.join(root_path, "#{path}.rb") }
+  lib_path = File.expand_path('..', __dir__)
+  adapter_paths = Dir.glob('adapters/*', base: lib_path).map { |path| File.join(lib_path, path) }
+  module_paths = %w[expressions/expression_helpers definitions/type_accessors definitions/redefiner].map do |path|
+    File.join(lib_path, "#{path}.rb")
+  end
 
   HIDDEN_PATHS = [File.expand_path(__FILE__), *adapter_paths, *module_paths].freeze
 

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module Low
   module Type
-    VERSION = '1.4.0'
+    VERSION = '1.5.1'
   end
 end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: lowtype
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.1
 platform: ruby
 authors:
 - maedi
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: dirload
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: expressions
   requirement: !ruby/object:Gem::Requirement
@@ -29,14 +43,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: trees
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "LowType introduces the concept of \"type expressions\" in method arguments.
   \nWhen an argument's default value resolves to a type instead of a value then it's
   treated as a type expression. \nNow you can have types in Ruby in the simplest syntax
@@ -49,6 +77,13 @@ extra_rdoc_files: []
 files:
 - lib/adapters/adapter_loader.rb
 - lib/adapters/sinatra_adapter.rb
+- lib/cli/cli.rb
+- lib/cli/rbs/class_sig.rb
+- lib/cli/rbs/exporter.rb
+- lib/cli/rbs/expression_mapper.rb
+- lib/cli/rbs/method_sig.rb
+- lib/cli/rbs/type_mapper.rb
+- lib/cli/type_stripper.rb
 - lib/definitions/evaluator.rb
 - lib/definitions/redefiner.rb
 - lib/definitions/type_accessors.rb