lowtype 1.3.2 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c777de40504eea68870df0ee7936de827b1e5a771aca97e40d1ef2b41d3e38ed
-  data.tar.gz: cab3b2a605413173922eee3680a18951f19ec28065e0eb320d5d649b99300c34
+  metadata.gz: 8fa1f2cac7f1067dd6d9c7c8f9a2c9d206cc22638c0223259a39909b65b8169f
+  data.tar.gz: bd3eaa654437ebabeecad44fccd7aa01cff8fb92d489318181c7d0fc0f757ebe
 SHA512:
-  metadata.gz: 7c4391bb32203a889a6a88ebdbe2895fd19bf8f195caa2a6d890475a5312fbb4b3e184bd5ea7a6d0031d95246411b8c56cf8323f62774aeda7d78b958f6bd2f0
-  data.tar.gz: d958d6ccd1f5d6c8c328aef5d7a12b2a46dc75253f82ed0f26d31da29666aa81f6e49e06515be901f6bd1ee5c4781e048131ef5d72505fd753da9135a52dee05
+  metadata.gz: ece1f0a96afaebdb246a4448875873fddd1eb8b2785a83f20c41f8960d46f6d37bab589743bec4fc945c237c8fef6cca5ce1a973133e81dcb08fddfdb39273a4
+  data.tar.gz: 5e5d946234acf6666fc3671d7027368fce3f0bcfcdf665083d45b15a6ea8bd56111c9c61f5ad3bbfeb09995ebce1563160c0a3c3eebb46d0902638077637e3be

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/definitions/redefiner.rb

@@ -26,25 +26,28 @@ module Low
   #      │              │                 │                 │               │
   class Redefiner
     class << self
-      # TODO: Pass in "klass" and use it to class_eval/eval methods in the binding of the class that included LowType.
-      def redefine(method_proxies:, class_proxy:)
-        if LowType.config.type_checking
-          typed_methods(method_proxies:, class_proxy:)
-        else
-          untyped_methods(method_proxies:, class_proxy:)
+      def redefine(method_proxies:, class_proxy:, klass: nil)
+        return typed_methods(method_proxies:, class_proxy:) if LowType.config.type_checking
+
+        case LowType.config.disable_mode
+        when :shim
+          shimmed_methods(method_proxies:, class_proxy:)
+        when :strip
+          strip_types(method_proxies:, class_proxy:, klass:)
         end
       end
 
-      def untyped_args(args:, kwargs:, method_proxy:) # rubocop:disable Metrics/AbcSize
+      def untyped_shimmed_args(args:, kwargs:, method_proxy:) # rubocop:disable Metrics/AbcSize
         method_proxy.params_with_expressions.each do |param_proxy|
-          value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
+          positional = %i[pos_req pos_opt].include?(param_proxy.type)
+          value = positional ? args[param_proxy.position] : kwargs[param_proxy.name]
 
           next unless value.nil?
           raise param_proxy.error_type, param_proxy.error_message(value:) if param_proxy.expression.required?
 
           value = param_proxy.expression.default_value # Default value can still be `nil`.
           value = value.value if value.is_a?(ValueExpression)
-          param_proxy.position ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
+          positional ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
         end
 
         [args, kwargs]
@@ -82,15 +85,13 @@ module Low
         end
       end
 
-      def untyped_methods(method_proxies:, class_proxy:)
+      def shimmed_methods(method_proxies:, class_proxy:)
         Module.new do
           method_proxies.values.filter(&:expressions?).each do |method_proxy|
-            # You are now in the binding of the includer class.
+            # You are now in the binding of both LowType and the includer class.
             define_method(method_proxy.name) do |*args, **kwargs|
-              # NOTE: Type checking is currently disabled. See 'config.type_checking'.
-              method_proxy = Lowkey[class_proxy.file_path][class_proxy.namespace][__method__]
-
-              args, kwargs = Low::Redefiner.untyped_args(args:, kwargs:, method_proxy:)
+              # NOTE: Type checking is currently disabled via shim. See 'config.type_checking'.
+              args, kwargs = Low::Redefiner.untyped_shimmed_args(args:, kwargs:, method_proxy:)
               super(*args, **kwargs)
             end
 
@@ -98,6 +99,20 @@ module Low
           end
         end
       end
+
+      def strip_types(method_proxies:, class_proxy:, klass:)
+        method_proxies.values.filter(&:expressions?).each do |method_proxy|
+          method_proxy.rewrite_signature
+
+          klass.class_eval(method_proxy.export, method_proxy.file_path, method_proxy.start_line)
+
+          if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
+            klass.send(:private, method_proxy.name)
+          end
+        end
+
+        nil
+      end
     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
 
@@ -18,7 +20,7 @@ module Low
     attr_reader :types, :default_value
 
     # @param type - A literal type or an instance representation of a typed structure.
-    def initialize(type: nil, default_value: :LOW_TYPE_UNDEFINED)
+    def initialize(type: nil, default_value: :LOWTYPE_UNDEFINED)
       @types = []
       @types << type unless type.nil?
       @default_value = default_value
@@ -27,9 +29,10 @@ module Low
     end
 
     def required?
-      @default_value == :LOW_TYPE_UNDEFINED
+      @default_value == :LOWTYPE_UNDEFINED
     end
 
+    # TODO: Might need to accept error class here so that type accessors can be disabled and supply ArgumentError.
     def validate!(value:, proxy:) # rubocop:disable Metrics
       if value.nil?
         return true if @default_value.nil?

data/lib/lowtype.rb

@@ -52,8 +52,11 @@ module LowType
 
       Low::Evaluator.evaluate(method_proxies: class_proxy.keyed_methods, class_binding: class_proxy.class_binding)
 
-      klass.prepend Low::Redefiner.redefine(method_proxies: class_proxy.instance_methods, class_proxy:)
-      klass.singleton_class.prepend Low::Redefiner.redefine(method_proxies: class_proxy.class_methods, class_proxy:)
+      result = Low::Redefiner.redefine(method_proxies: class_proxy.instance_methods, class_proxy:, klass:)
+      klass.prepend result if result.is_a?(Module)
+
+      singleton_result = Low::Redefiner.redefine(method_proxies: class_proxy.class_methods, class_proxy:, klass: klass.singleton_class)
+      klass.singleton_class.prepend singleton_result if singleton_result.is_a?(Module)
 
       Low::Adapter::Loader.load(klass:, class_proxy:)
 
@@ -65,6 +68,7 @@ module LowType
 
   Config = Struct.new(
     :type_checking,
+    :disable_mode,
     :error_mode,
     :output_mode,
     :output_size,
@@ -74,7 +78,7 @@ module LowType
 
   class << self
     def config
-      @config ||= Config.new(true, :error, :type, 100, true, true)
+      @config ||= Config.new(true, :shim, :error, :type, 100, true, true)
     end
 
     def configure

data/lib/proxies/param_proxy.rb

@@ -9,10 +9,14 @@ module ::Lowkey
   class ParamProxy
     include ::Low::ErrorHandling
 
+    # Error type should be an ArgumentError when type checking disabled via shim methods.
     def error_type
-      ::Low::ArgumentTypeError
+      return ::Low::ArgumentTypeError if LowType.config.type_checking
+
+      ArgumentError
     end
 
+    # When shimmed the error message will be from LowType, when stripped standard Ruby.
     def error_message(value:)
       "Invalid argument type '#{output(value:)}' for parameter '#{@name}'. Valid types: '#{@expression.valid_types}'"
     end

data/lib/types/error_types.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Low
-  class ArgumentTypeError < TypeError; end
+  class ArgumentTypeError < ArgumentError; end
   class LocalTypeError < TypeError; end
   class ReturnTypeError < TypeError; end
   class AllowedTypeError < TypeError; end

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module Low
   module Type
-    VERSION = '1.3.2'
+    VERSION = '1.5.0'
   end
 end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: lowtype
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.5.0
 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
@@ -37,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
+- !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