kapusta 0.13.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b547075d7dcb73121e61dc17577cb8262265eaffb6ee0d74b88a74ce83c8e09a
-  data.tar.gz: 877f490eca3f0d4419e38b4619f77470aff18ddd8fede555f2963beb8db5994f
+  metadata.gz: 9324827934a0647689027ecf5fc6bf83708fe536cd904dc04d1f9c0594c37581
+  data.tar.gz: 736a8f7d8158fc4502415168f5791d7af8b98f392800255576c1d0182ef920c6
 SHA512:
-  metadata.gz: cddc220382f4c7f59788f4624f9e86f55bc58fe2b3fa6978f4e6d8bebaa870ff73be57786ecf2db94f14d6db460b3f485b6f82195e7fd21e255c7a7612ab50c2
-  data.tar.gz: 6c653e095b1c3d406f95e7f1659b615a2a59eaa21ef77e709cfc2dfc398d3526fb493f5054cb541acd36b203e690dbc28626e951e3e8f9d5e27366c0d5885834
+  metadata.gz: 62e4118362c7fbe7ae034470a01ddf37a0bb826fb142e2611d72b09ded1777e52bf2b078cf48c0283dda6f0a8c5989ec31f60d0913cf16ec3ac9ccabf2c40626
+  data.tar.gz: 5fbd5b3a7809eff626c43203b1c36761efac10cb5663ca345ace26fbea731da63402909be6a04f22aedaca80945e1db3456209a6ac335b8fc4a2152bcc198395

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,6 +488,10 @@ 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
@@ -501,6 +505,7 @@ module Kapusta
           /\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\([^()\n]*\)(?:\.[a-zA-Z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/, # (expr).chain
           /\A:[a-zA-Z_]\w*[!?=]?\z/, # :symbol
           /\A"(?:[^"\\]|\\.)*"\z/, # "string"
           /\A'(?:[^'\\]|\\.)*'\z/, # 'string'

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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kapusta
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.13.1
 platform: ruby
 authors:
 - Evgenii Morozov