kapusta 0.13.0 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b547075d7dcb73121e61dc17577cb8262265eaffb6ee0d74b88a74ce83c8e09a
-  data.tar.gz: 877f490eca3f0d4419e38b4619f77470aff18ddd8fede555f2963beb8db5994f
+  metadata.gz: fa363e8e708ddf94ca3406bda52d7603663e9de82a79eec94328082f5310b638
+  data.tar.gz: cf1a0911c16fa481bc1680380eb2677329276289c513e8d66d9f4450cad9d762
 SHA512:
-  metadata.gz: cddc220382f4c7f59788f4624f9e86f55bc58fe2b3fa6978f4e6d8bebaa870ff73be57786ecf2db94f14d6db460b3f485b6f82195e7fd21e255c7a7612ab50c2
-  data.tar.gz: 6c653e095b1c3d406f95e7f1659b615a2a59eaa21ef77e709cfc2dfc398d3526fb493f5054cb541acd36b203e690dbc28626e951e3e8f9d5e27366c0d5885834
+  metadata.gz: d2e4405abbab87cc70e8b00ab05840f50b6050c965d63351e6db3a2e5ab2f97219bb517d837ef8f8166df27ae4d53d0bd9a595de6bbed3d5e0319de0c13b2a88
+  data.tar.gz: 8e88867b98adba5e17d0eaf6a506518bdb0a7f7b2628d5ce3937fad5f29e73766dba4767340716f06ec7ff3e9b68df6924b7cadf936a71cb18bf47e88a26ca4b

data/lib/kapusta/compiler/emitter/bindings.rb

@@ -18,11 +18,11 @@ module Kapusta
             fn_env = env.child
             ruby_name = define_local(fn_env, name_sym.name)
             <<~RUBY.chomp
-              (-> do
+              lambda do
                 #{ruby_name} = nil
                 #{ruby_name} = #{emit_lambda(pattern, body, fn_env, current_scope)}
                 #{ruby_name}
-              end).call
+              end.call
             RUBY
           end
         end
@@ -259,9 +259,9 @@ module Kapusta
         def emit_let(args, env, current_scope)
           binding_code, body_code = emit_let_parts(args, env, current_scope, result: true)
           [
-            '(-> do',
+            'lambda do',
             indent(join_code(binding_code, body_code)),
-            'end).call'
+            'end.call'
           ].join("\n")
         end
 
@@ -293,7 +293,23 @@ module Kapusta
           body_code, = emit_sequence(body, child_env, current_scope,
                                      allow_method_definitions: false,
                                      result:)
-          [binding_codes.reject(&:empty?).join("\n"), body_code]
+          [join_binding_codes(binding_codes), body_code]
+        end
+
+        def join_binding_codes(binding_codes)
+          codes = binding_codes.reject(&:empty?)
+          return '' if codes.empty?
+
+          result = codes.first.dup
+          codes.each_cons(2) do |prev, curr|
+            separator = block_binding?(prev) || block_binding?(curr) ? "\n\n" : "\n"
+            result << separator << curr
+          end
+          result
+        end
+
+        def block_binding?(code)
+          code.match?(/\bdo\b/) && code.match?(/\bend\b/)
         end
 
         def join_code(*chunks)
@@ -376,7 +392,7 @@ module Kapusta
 
         def emit_local_expr(args, env, current_scope)
           code, = emit_local_form(List.new([Sym.new('local'), *args]), env.child, current_scope)
-          "(-> do\n#{indent(code)}\nend).call"
+          "lambda do\n#{indent(code)}\nend.call"
         end
 
         def emit_global_expr(args, _env, _current_scope)

data/lib/kapusta/compiler/emitter/collections.rb

@@ -89,11 +89,11 @@ module Kapusta
             emit_sequence_value_assignment(acc_var, body_code)
           end
           [
-            '(-> do',
+            'lambda do',
             indent("#{acc_var} = #{init_code}"),
             indent(iter_code),
             indent(acc_var),
-            'end).call'
+            'end.call'
           ].join("\n")
         end
 
@@ -221,11 +221,11 @@ module Kapusta
 
         def emit_collection_result(result_var, initial_code, iter_code)
           [
-            '(-> do',
+            'lambda do',
             indent("#{result_var} = #{initial_code}"),
             indent(iter_code),
             indent(result_var),
-            'end).call'
+            'end.call'
           ].join("\n")
         end
 

data/lib/kapusta/compiler/emitter/control_flow.rb

@@ -61,10 +61,10 @@ module Kapusta
           return body unless value_var
 
           [
-            '(-> do',
+            'lambda do',
             indent("#{value_var} = #{value_code}"),
             indent(body),
-            'end).call'
+            'end.call'
           ].join("\n")
         end
 
@@ -212,30 +212,30 @@ module Kapusta
 
         def emit_while(args, env, current_scope)
           <<~RUBY.chomp
-            (-> do
+            lambda do
               #{indent(emit_while_statement(args, env, current_scope))}
               nil
-            end).call
+            end.call
           RUBY
         end
 
         def emit_for(args, env, current_scope)
           loop_code = emit_for_statement(args, env, current_scope)
           <<~RUBY.chomp
-            (-> do
+            lambda do
               #{indent(loop_code)}
               nil
-            end).call
+            end.call
           RUBY
         end
 
         def emit_each(args, env, current_scope)
           iter_code = emit_each_statement(args, env, current_scope)
           <<~RUBY.chomp
-            (-> do
+            lambda do
               #{iter_code}
               nil
-            end).call
+            end.call
           RUBY
         end
 

data/lib/kapusta/compiler/emitter/interop.rb

@@ -35,7 +35,7 @@ module Kapusta
           if literal_name && binary_operator_call?(literal_name.to_s, positional, kwargs, block_form)
             return emit_binary_operator_call(receiver, literal_name.to_s, positional[0])
           end
-          if literal_name && direct_method_name?(literal_name.to_s)
+          if literal_name && colon_call_direct_method_name?(literal_name.to_s)
             return emit_direct_method_call(receiver, Kapusta.kebab_to_snake(literal_name.to_s),
                                            positional, kwargs, block_form, env, current_scope)
           end
@@ -99,7 +99,7 @@ module Kapusta
           segments = constant_segments(name_sym)
           emit_error!(:invalid_module_name, name: name_sym.name) unless segments
           inner = build_nested_module(segments, body)
-          ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
+          ['lambda do', indent(inner), indent(segments.join('::')), 'end.call'].join("\n")
         end
 
         def emit_direct_module_header(name_sym, body)
@@ -114,7 +114,7 @@ module Kapusta
           emit_error!(:invalid_class_name, name: name_sym.name) unless segments
           super_code = class_super_code(supers, env)
           inner = build_nested_class(segments, super_code, body)
-          ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
+          ['lambda do', indent(inner), indent(segments.join('::')), 'end.call'].join("\n")
         end
 
         def emit_direct_class_header(name_sym, supers, body, env)
@@ -488,40 +488,16 @@ module Kapusta
           Kapusta.kebab_to_snake(name).match?(/\A[a-z_]\w*[!?=]?\z/)
         end
 
+        def colon_call_direct_method_name?(name)
+          Kapusta.kebab_to_snake(name).match?(/\A[a-zA-Z_]\w*[!?=]?\z/)
+        end
+
         def global_name(name)
           Kapusta.kebab_to_snake(name).gsub(/[^a-zA-Z0-9_]/, '_')
         end
 
-        SIMPLE_EXPRESSION_PATTERNS = [
-          /\A[a-z_]\w*\z/, # local
-          /\A@@?[a-z_]\w*\z/, # @ivar / @@cvar
-          /\A\$[a-zA-Z_]\w*\z/, # $gvar
-          /\A[A-Z]\w*(?:::[A-Z]\w*)*\z/, # Constant / A::B::C
-          /\A[a-z_]\w*[!?=]?\([^()\n]*\)\z/, # bare call foo(...)
-          /\A-?\d+(?:\.\d+)?\z/, # number
-          /\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # local + .m/[k] chain
-          /\A[A-Z]\w*(?:::[A-Z]\w*)*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # const + chain
-          /\A:[a-zA-Z_]\w*[!?=]?\z/, # :symbol
-          /\A"(?:[^"\\]|\\.)*"\z/, # "string"
-          /\A'(?:[^'\\]|\\.)*'\z/, # 'string'
-          /\A\[[^\[\]\n]*\]\z/ # [flat, array]
-        ].freeze
-        private_constant :SIMPLE_EXPRESSION_PATTERNS
-
-        SIMPLE_EXPRESSION_KEYWORDS = %w[nil true false self].freeze
-        private_constant :SIMPLE_EXPRESSION_KEYWORDS
-
         def simple_expression?(code)
-          SIMPLE_EXPRESSION_PATTERNS.any? { |re| code.match?(re) } ||
-            SIMPLE_EXPRESSION_KEYWORDS.include?(code) ||
-            negation_simple?(code)
-        end
-
-        def negation_simple?(code)
-          return false unless code.start_with?('!') && code.length > 1
-
-          rest = code[1..]
-          simple_expression?(rest) || (rest.start_with?('(') && rest.end_with?(')'))
+          SimpleExpression.match?(code)
         end
       end
     end

data/lib/kapusta/compiler/emitter/simple_expression.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module EmitterModules
+      module SimpleExpression
+        module_function
+
+        KEYWORDS = %w[nil true false self].freeze
+
+        OPENERS = { '(' => ')', '[' => ']', '{' => '}' }.freeze
+        CLOSERS = OPENERS.values.freeze
+
+        # `{...}` is intentionally excluded — a top-level hash or block literal
+        # shouldn't be treated as a bare primary even though balanced.
+        PRIMARY_OPENERS = { '(' => ')', '[' => ']' }.freeze
+
+        PRIMARY_PATTERNS = [
+          /\A-?\d+(?:\.\d+)?/, # number (incl. negative literal)
+          /\A:[a-zA-Z_]\w*[!?=]?/, # :symbol
+          /\A"(?:[^"\\]|\\.)*"/, # "string"
+          /\A'(?:[^'\\]|\\.)*'/, # 'string'
+          /\A@@?[a-z_]\w*/, # @ivar / @@cvar
+          /\A\$[a-zA-Z_]\w*/, # $gvar
+          /\A[A-Z]\w*(?:::[A-Z]\w*)*/, # Constant / A::B::C
+          /\A[a-z_]\w*[!?=]?/ # local or bare call head
+        ].freeze
+
+        CHAIN_METHOD = /\A\.[a-zA-Z_]\w*[!?=]?/
+
+        def match?(code)
+          return false if code.empty? || code.include?("\n")
+          return true if KEYWORDS.include?(code)
+          return negation?(code) if code.start_with?('!')
+
+          consume(code, 0) == code.length
+        end
+
+        def negation?(code)
+          return false if code.length < 2
+
+          rest = code[1..]
+          match?(rest) || (rest.start_with?('(') && rest.end_with?(')'))
+        end
+
+        def consume(code, pos)
+          pos = consume_primary(code, pos)
+          while pos && pos < code.length
+            advanced = consume_segment(code, pos)
+            break unless advanced
+
+            pos = advanced
+          end
+          pos
+        end
+
+        def consume_primary(code, pos)
+          return consume_group(code, pos) if PRIMARY_OPENERS.key?(code[pos])
+
+          regex = PRIMARY_PATTERNS.find { |re| code[pos..].match?(re) }
+          return unless regex
+
+          after = pos + regex.match(code[pos..]).end(0)
+          code[after] == '(' ? consume_group(code, after) : after
+        end
+
+        def consume_segment(code, pos)
+          return consume_group(code, pos) if code[pos] == '['
+          return unless code[pos] == '.'
+
+          match = CHAIN_METHOD.match(code[pos..])
+          return unless match
+
+          after = pos + match.end(0)
+          code[after] == '(' ? consume_group(code, after) : after
+        end
+
+        def consume_group(code, pos)
+          return unless OPENERS.key?(code[pos])
+
+          stack = [OPENERS[code[pos]]]
+          pos += 1
+          quote = nil
+          while pos < code.length
+            ch = code[pos]
+            if quote
+              if ch == '\\' && pos + 1 < code.length
+                pos += 2
+              else
+                quote = nil if ch == quote
+                pos += 1
+              end
+            elsif ['"', "'"].include?(ch)
+              quote = ch
+              pos += 1
+            elsif OPENERS.key?(ch)
+              stack.push(OPENERS[ch])
+              pos += 1
+            elsif CLOSERS.include?(ch)
+              return unless stack.last == ch
+
+              stack.pop
+              pos += 1
+              return pos if stack.empty?
+            else
+              pos += 1
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/kapusta/compiler/emitter/support.rb

@@ -158,11 +158,38 @@ module Kapusta
             emit_sequence_statement_form(form, env, current_scope, result_needed:)
           elsif set_new_local_form?(form, env)
             emit_set_form(form, env, current_scope)
+          elsif !result_needed && class_or_module_form?(form)
+            [emit_class_or_module_statement(form, env), env]
           else
             [emit_expr(form, env, current_scope), env]
           end
         end
 
+        def class_or_module_form?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) &&
+            %w[class module].include?(form.head.name)
+        end
+
+        def emit_class_or_module_statement(form, env)
+          args = form.rest
+          if form.head.name == 'module'
+            name_sym = args[0]
+            body = with_class_body do
+              emit_sequence(args[1..], env.child, :module, allow_method_definitions: true,
+                                                           result: false).first
+            end
+            emit_direct_module_header(name_sym, body) || emit_module_wrapper(name_sym, body)
+          else
+            name_sym, supers, body_forms = split_class_args(args)
+            body = with_class_body do
+              emit_sequence(body_forms, env.child, :class, allow_method_definitions: true,
+                                                           result: false).first
+            end
+            emit_direct_class_header(name_sym, supers, body, env) ||
+              emit_class_wrapper(name_sym, supers, env, body)
+          end
+        end
+
         def emit_do_form(forms, env, current_scope, result_needed: true)
           body, new_env = emit_sequence(forms, env, current_scope,
                                         allow_method_definitions: false,

data/lib/kapusta/compiler/emitter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'emitter/simple_expression'
 require_relative 'emitter/support'
 require_relative 'emitter/expressions'
 require_relative 'emitter/bindings'

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.13.0'
+  VERSION = '0.13.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.13.2
 platform: ruby
 authors:
 - Evgenii Morozov
@@ -153,6 +153,7 @@ files:
 - lib/kapusta/compiler/emitter/expressions.rb
 - lib/kapusta/compiler/emitter/interop.rb
 - lib/kapusta/compiler/emitter/patterns.rb
+- lib/kapusta/compiler/emitter/simple_expression.rb
 - lib/kapusta/compiler/emitter/support.rb
 - lib/kapusta/compiler/lua_compat.rb
 - lib/kapusta/compiler/macro_expander.rb