kapusta 0.13.2 → 0.14.0

data/lib/kapusta/compiler/macro_expander.rb

@@ -32,18 +32,16 @@ module Kapusta
       private
 
       def expand_top(form)
-        if form.is_a?(List) && form.head.is_a?(Sym)
-          case form.head.name
-          when 'macro'
-            register_macro_form(form.rest)
-            return []
-          when 'macros'
-            register_macros_form(form.rest)
-            return []
-          when 'import-macros'
-            handle_import_macros(form)
-            return []
-          end
+        case Language.list_head_name(form)
+        when 'macro'
+          register_macro_form(form.rest)
+          return []
+        when 'macros'
+          register_macros_form(form.rest)
+          return []
+        when 'import-macros'
+          handle_import_macros(form)
+          return []
         end
         [expand(form)]
       end
@@ -104,11 +102,11 @@ module Kapusta
       end
 
       def register_macro_form(args)
-        name_sym, params, *body = args
-        raise macro_error(:macro_name_must_be_symbol, name_sym) unless name_sym.is_a?(Sym)
-        raise macro_error(:macro_params_must_be_vector, params) unless params.is_a?(Vec)
+        parsed = Language.parse_macro_definition_args(args)
+        raise macro_error(:macro_name_must_be_symbol, parsed.name) unless parsed.name.is_a?(Sym)
+        raise macro_error(:macro_params_must_be_vector, parsed.params) unless parsed.params.is_a?(Vec)
 
-        register(name_sym.name, params, body)
+        register(parsed.name.name, parsed.params, parsed.body)
       end
 
       def register_macros_form(args)
@@ -116,11 +114,15 @@ module Kapusta
         raise macro_error(:macros_expects_hash, hash_lit) unless hash_lit.is_a?(HashLit)
 
         hash_lit.pairs.each do |key, value|
-          raise macro_error(:macros_entry_must_be_fn, value, form: value.inspect) unless fn_form?(value)
+          unless Language.function_head?(Language.list_head_name(value))
+            raise macro_error(:macros_entry_must_be_fn, value, form: value.inspect)
+          end
+
+          parsed = Language.parse_function_form(value)
 
           name = key.to_s
-          params = value.items[1]
-          body = value.items[2..]
+          params = parsed&.named? ? value.items[1] : (parsed&.params || value.items[1])
+          body = parsed&.body || value.items[2..]
           raise macro_error(:macros_entry_params_must_be_vector, params) unless params.is_a?(Vec)
 
           register(name, params, body)
@@ -128,26 +130,24 @@ module Kapusta
       end
 
       def fn_form?(value)
-        value.is_a?(List) && value.head.is_a?(Sym) && %w[fn lambda λ].include?(value.head.name)
+        Language.function_form?(value)
       end
 
       def handle_import_macros(form)
-        args = form.rest
-        destructure = args[0]
-        module_arg = args[1]
-        unless destructure.is_a?(HashLit) || destructure.is_a?(Sym)
+        parsed = Language.parse_import_macros_args(form.rest)
+        unless parsed.destructure.is_a?(HashLit) || parsed.destructure.is_a?(Sym)
           raise macro_error(:import_macros_destructure_invalid, form)
         end
-        unless module_arg.is_a?(Symbol) || module_arg.is_a?(String)
+        unless parsed.module_arg.is_a?(Symbol) || parsed.module_arg.is_a?(String)
           raise macro_error(:import_macros_module_invalid, form)
         end
 
-        module_label = MacroImporter.module_label(module_arg)
-        exports = macro_importer.load(module_arg, form)
-        if destructure.is_a?(HashLit)
-          register_imported_macros(destructure, exports, module_label, form)
+        module_label = MacroImporter.module_label(parsed.module_arg)
+        exports = macro_importer.load(parsed.module_arg, form)
+        if parsed.destructure.is_a?(HashLit)
+          register_imported_macros(parsed.destructure, exports, module_label, form)
         else
-          register_whole_module(destructure, exports)
+          register_whole_module(parsed.destructure, exports)
         end
       end
 

data/lib/kapusta/compiler/macro_lowerer.rb

@@ -5,8 +5,6 @@ require_relative 'macro_gensym'
 module Kapusta
   module Compiler
     class MacroLowerer
-      FN_HEADS = %w[fn lambda λ].freeze
-
       def self.compile(params:, body:, path:, error_class:)
         callable = new(error_class:).callable_form(params, body)
         ruby = Compiler.compile_forms([callable], path:)
@@ -56,21 +54,11 @@ module Kapusta
       private
 
       def lower_fn_form(form)
-        items = form.items
-        if items[1].is_a?(Sym) && items[2].is_a?(Vec)
-          name_sym = items[1]
-          params = items[2]
-          body = items[3..] || []
-        elsif items[1].is_a?(Vec)
-          name_sym = nil
-          params = items[1]
-          body = items[2..] || []
-        else
-          return form
-        end
+        parsed = Language.parse_function_form(form)
+        return form unless parsed
 
-        head_items = name_sym ? [form.head, name_sym, params] : [form.head, params]
-        List.new(head_items + lowered_body_with_gensyms(body))
+        head_items = parsed.named? ? [form.head, parsed.name, parsed.params] : [form.head, parsed.params]
+        List.new(head_items + lowered_body_with_gensyms(parsed.body))
       end
 
       def lowered_body_with_gensyms(body)
@@ -91,7 +79,7 @@ module Kapusta
       end
 
       def fn_form?(form)
-        form.is_a?(List) && form.head.is_a?(Sym) && FN_HEADS.include?(form.head.name)
+        Language.function_form?(form)
       end
 
       def lower_quasi(form)
@@ -147,8 +135,8 @@ module Kapusta
       end
 
       def lower_quasi_item(item)
-        if item.is_a?(Unquote) && unpack_call?(item.form)
-          inner = lower(item.form.items[1])
+        if item.is_a?(Unquote) && (unpack = Language.parse_unpack_call(item.form))
+          inner = lower(unpack.value)
           List.new([Sym.new('.'), inner, 0])
         else
           lower_quasi(item)
@@ -159,13 +147,13 @@ module Kapusta
         last = items.last
         return unless last
         return lower(last.form) if last.is_a?(UnquoteSplice)
-        return lower(last.form.items[1]) if last.is_a?(Unquote) && unpack_call?(last.form)
 
-        nil
-      end
+        if last.is_a?(Unquote)
+          unpack = Language.parse_unpack_call(last.form)
+          return lower(unpack.value) if unpack
+        end
 
-      def unpack_call?(form)
-        form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'unpack'
+        nil
       end
 
       def gensym_local_for(prefix)

data/lib/kapusta/compiler/normalizer.rb

@@ -41,27 +41,27 @@ module Kapusta
 
         case head.name
         when 'when'
-          raise compiler_error(:when_no_body, list, form: head.name) if items[2..].empty?
+          parsed = Language.parse_conditional_body_args(items[1..])
+          raise compiler_error(:when_no_body, list, form: head.name) unless parsed.body?
 
-          cond = items[1]
-          body = wrap_do(items[2..])
-          Kapusta.copy_position(List.new([Sym.new('if'), cond, body]), list)
+          Kapusta.copy_position(List.new([Sym.new('if'), parsed.condition, wrap_do(parsed.body)]), list)
         when 'unless'
-          raise compiler_error(:when_no_body, list, form: head.name) if items[2..].empty?
+          parsed = Language.parse_conditional_body_args(items[1..])
+          raise compiler_error(:when_no_body, list, form: head.name) unless parsed.body?
 
-          cond = items[1]
-          body = wrap_do(items[2..])
-          Kapusta.copy_position(List.new([Sym.new('if'), List.new([Sym.new('not'), cond]), body]), list)
+          negated = List.new([Sym.new('not'), parsed.condition])
+          Kapusta.copy_position(List.new([Sym.new('if'), negated, wrap_do(parsed.body)]), list)
         when 'tset'
-          raise compiler_error(:tset_no_value, list) if items.length < 4
+          parsed = Language.parse_tset_args(items[1..])
+          raise compiler_error(:tset_no_value, list) unless parsed
 
           Kapusta.copy_position(
-            List.new([Sym.new('set'), List.new([Sym.new('.'), items[1], items[2]]), items[3]]),
+            List.new([Sym.new('set'), List.new([Sym.new(':'), parsed.table, parsed.key]), parsed.value]),
             list
           )
         when *LuaCompat::SPECIAL_FORMS
           normalize_lua_compat_form(head.name, items)
-        when '->', '->>', '-?>', '-?>>'
+        when *Language::THREAD_HEADS
           Kapusta.copy_position(normalize(thread(items[1..], head.name)), list)
         when 'doto'
           Kapusta.copy_position(normalize(doto(items[1..])), list)
@@ -85,8 +85,8 @@ module Kapusta
 
       def thread(forms, kind)
         value = forms.first
-        short = %w[-?> -?>>].include?(kind)
-        position = %w[-> -?>].include?(kind) ? :first : :last
+        short = Language.short_pipeline_head?(kind)
+        position = Language.thread_first_head?(kind) ? :first : :last
 
         return thread_short(forms, position) if short
 
@@ -124,9 +124,9 @@ module Kapusta
       def thread_step(memo, form, position)
         if form.is_a?(List)
           if position == :first
-            List.new([form.items[0], memo, *form.items[1..]])
+            prepend_call_arg(form, memo)
           else
-            List.new([*form.items, memo])
+            append_call_arg(form, memo)
           end
         else
           List.new([form, memo])
@@ -144,19 +144,27 @@ module Kapusta
         temp = gensym('doto')
         body = forms[1..].map do |form|
           if form.is_a?(List)
-            List.new([form.items[0], temp, *form.items[1..]])
+            prepend_call_arg(form, temp)
           else
             List.new([form, temp])
           end
         end
         fn = List.new([Sym.new('fn'), Vec.new([temp]), *body])
-        List.new([Sym.new(':'), value, :tap, fn])
+        List.new([Sym.new('.'), value, :tap, fn])
       end
 
       def gensym(prefix)
         @gensym_index = (@gensym_index || 0) + 1
         GeneratedSym.new("#{prefix}_#{@gensym_index}", @gensym_index)
       end
+
+      def prepend_call_arg(form, value)
+        List.new([form.head, value, *form.rest])
+      end
+
+      def append_call_arg(form, value)
+        List.new([*form.items, value])
+      end
     end
   end
 end

data/lib/kapusta/compiler.rb

@@ -2,6 +2,7 @@
 
 require_relative 'error'
 require_relative 'compiler/lua_compat'
+require_relative 'compiler/language'
 require_relative 'compiler/normalizer'
 require_relative 'compiler/emitter'
 require_relative 'compiler/macro_expander'
@@ -9,30 +10,8 @@ require_relative 'compiler/macro_expander'
 module Kapusta
   module Compiler
     class Error < Kapusta::Error; end
-    CORE_SPECIAL_FORMS = %w[
-      fn defn lambda λ let local var global set if when unless case match
-      while for each do values
-      -> ->> -?> -?>> doto
-      icollect collect fcollect accumulate faccumulate
-      hashfn
-      . ?. :
-      ..
-      length
-      require
-      module class end
-      try catch finally
-      raise
-      ivar cvar gvar
-      ruby
-      tset
-      and or not
-      = not= < <= > >=
-      + - * / %
-      print
-      macro macros import-macros
-      quasi-sym quasi-list quasi-list-tail quasi-vec quasi-vec-tail quasi-hash quasi-gensym
-    ].freeze
-    SPECIAL_FORMS = (CORE_SPECIAL_FORMS + LuaCompat::SPECIAL_FORMS).freeze
+    CORE_SPECIAL_FORMS = Language::CORE_SPECIAL_FORMS
+    SPECIAL_FORMS = Language::SPECIAL_FORMS
 
     def self.compile(source, path: '(kapusta)', target: nil)
       forms = Reader.read_all(source)

data/lib/kapusta/env.rb

@@ -2,8 +2,8 @@
 
 module Kapusta
   class Env
-    MethodBinding = Struct.new(:ruby_name)
-    SelfMethodBinding = Struct.new(:ruby_name)
+    MethodBinding = Struct.new(:ruby_name, :multi_return)
+    SelfMethodBinding = Struct.new(:ruby_name, :multi_return)
 
     def initialize(parent = nil)
       @parent = parent

data/lib/kapusta/errors.rb

@@ -6,7 +6,7 @@ module Kapusta
     MESSAGES = {
       accumulate_no_iterator: 'expected initial value and iterator binding table',
       auto_gensym_outside_quasiquote: 'auto-gensym %{name}# outside quasiquote',
-      bad_multisym: 'bad multisym: %{path}',
+      bad_multisym: 'bad multisym: %{path}; unresolved root %{segment}; %{suggestion}',
       bad_set_target: 'bad set target: %{target}',
       bad_shorthand: 'bad shorthand',
       bind_table_dots: 'unable to bind table ...',
@@ -42,6 +42,7 @@ module Kapusta
       import_macros_module_no_exports: 'import-macros: module %{module} has no export table',
       import_macros_module_not_found: 'import-macros: module %{module} not found',
       invalid_class_name: 'invalid class name: %{name}',
+      invalid_header_body_form: '%{scope} body form must be a declaration or known special form: %{name}',
       invalid_module_name: 'invalid module name: %{name}',
       let_no_body: 'expected body expression',
       let_odd_bindings: 'expected even number of name/value bindings',

data/lib/kapusta/formatter/ast_helpers.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class Formatter
+    module ASTHelpers
+      private
+
+      def comment?(form)
+        form.is_a?(Comment)
+      end
+
+      def blank_line?(form)
+        form.is_a?(BlankLine)
+      end
+
+      def non_semantic?(form)
+        comment?(form) || blank_line?(form)
+      end
+
+      def contains_comments?(items)
+        items.any? { |item| non_semantic?(item) }
+      end
+
+      def semantic_items(items)
+        items.reject { |item| non_semantic?(item) }
+      end
+
+      def list_head(list)
+        semantic_items(list.items).first
+      end
+
+      def head_name(list)
+        head = list_head(list)
+        head.name if head.is_a?(Sym)
+      end
+
+      def list_rest(list)
+        semantic_items(list.items).drop(1)
+      end
+
+      def list_raw_rest(list)
+        index = list.items.index { |item| !non_semantic?(item) }
+        return list.items if index.nil?
+
+        list.items[(index + 1)..] || []
+      end
+
+      def split_raw_items(items, semantic_count)
+        split_index = 0
+        seen = 0
+
+        while split_index < items.length && seen < semantic_count
+          seen += 1 unless non_semantic?(items[split_index])
+          split_index += 1
+        end
+
+        [items.take(split_index), items.drop(split_index)]
+      end
+
+      def multiline_in_source?(form)
+        form.respond_to?(:multiline_source) && form.multiline_source
+      end
+
+      def contains_collection?(form)
+        case form
+        when List then semantic_items(form.items).any? { |item| collection?(item) }
+        when Vec then form.items.any? { |item| collection?(item) }
+        when HashLit then form.pairs.any? { |k, v| collection?(k) || collection?(v) }
+        else false
+        end
+      end
+
+      def collection?(form)
+        form.is_a?(List) || form.is_a?(Vec) || form.is_a?(HashLit)
+      end
+    end
+  end
+end

data/lib/kapusta/formatter/cli.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class Formatter
+    module CLI
+      def initialize(argv)
+        @mode = :stdout
+        @files = []
+        @version = false
+        parse_args(argv)
+      end
+
+      def run
+        return print_version if @version
+
+        validate_args!
+        apply_mode(formatted_files)
+      rescue Kapusta::Error => e
+        warn e.formatted
+        1
+      end
+
+      private
+
+      def print_version
+        puts "kapfmt #{Kapusta::VERSION}"
+        0
+      end
+
+      def formatted_files
+        @files.map { |path| formatted_file(path) }
+      end
+
+      def formatted_file(path)
+        original = read_source(path)
+        validate_kapusta_source(original, path)
+        [path, original, format_source(original, path)]
+      end
+
+      def apply_mode(formatted)
+        case @mode
+        when :stdout
+          $stdout.write(formatted.first[2])
+        when :fix
+          fix_files(formatted)
+        when :check
+          return check_files(formatted)
+        end
+
+        0
+      end
+
+      def fix_files(formatted)
+        formatted.each do |path, _original, rewritten|
+          raise Error, 'Cannot use --fix with stdin (-).' if stdin_path?(path)
+
+          File.write(path, rewritten)
+        end
+      end
+
+      def check_files(formatted)
+        dirty = formatted.reject { |_path, original, rewritten| original == rewritten }
+        dirty.each do |path, _original, _rewritten|
+          warn "Not formatted: #{path}"
+        end
+
+        dirty.empty? ? 0 : 1
+      end
+
+      def parse_args(argv)
+        argv.each do |arg|
+          case arg
+          when '--fix'
+            ensure_mode!(:fix)
+          when '--check'
+            ensure_mode!(:check)
+          when '--version', '-v'
+            @version = true
+          when '--help', '-h'
+            print_help
+            exit 0
+          else
+            @files << arg
+          end
+        end
+      end
+
+      def ensure_mode!(mode)
+        raise Error, 'Use at most one of --fix or --check.' if @mode != :stdout && @mode != mode
+
+        @mode = mode
+      end
+
+      def validate_args!
+        raise Error, 'Usage: kapfmt [--fix] [--check] FILENAME...' if @files.empty?
+        raise Error, 'stdin (-) may only be specified once.' if @files.count { |path| stdin_path?(path) } > 1
+        raise Error, 'Cannot use --fix with stdin (-).' if @mode == :fix && @files.any? { |path| stdin_path?(path) }
+
+        return unless @mode == :stdout && @files.length != 1
+
+        raise Error, 'Without --fix or --check, kapfmt accepts exactly one file.'
+      end
+
+      def read_source(path)
+        return File.read(path) unless stdin_path?(path)
+
+        @stdin_read ||= false
+        raise Error, 'stdin (-) may only be specified once.' if @stdin_read
+
+        @stdin_read = true
+        $stdin.read
+      end
+
+      def stdin_path?(path)
+        path == STDIN_PATH
+      end
+
+      def print_help
+        puts 'Usage: kapfmt [--fix] [--check] FILENAME...'
+        puts
+        puts 'Formats Kapusta source using the built-in Kapusta reader and pretty-printer.'
+      end
+    end
+  end
+end

data/lib/kapusta/formatter/line_helpers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class Formatter
+    module LineHelpers
+      private
+
+      def fits?(text, indent)
+        fits_within?(text, indent, MAX_WIDTH)
+      end
+
+      def inline_arg_fits?(text, indent)
+        fits_within?(text, indent, MAX_WIDTH - 1)
+      end
+
+      def fits_within?(text, indent, width)
+        !text.include?("\n") && indent + text.length <= width
+      end
+
+      def single_line?(text)
+        !text.include?("\n")
+      end
+
+      def indent_block(text, amount)
+        prefix = ' ' * amount
+        text.lines.map { |line| line.strip.empty? ? blank_line_for(line) : "#{prefix}#{line}" }.join
+      end
+
+      def blank_line_for(line)
+        line.end_with?("\n") ? "\n" : ''
+      end
+
+      def append_suffix(lines, suffix)
+        updated = lines.dup
+        if updated[-1].lstrip.start_with?(';')
+          updated << suffix
+        else
+          updated[-1] = "#{updated[-1]}#{suffix}"
+        end
+        updated.join("\n")
+      end
+    end
+  end
+end

data/lib/kapusta/formatter/validator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class Formatter
+    module Validator
+      private
+
+      def validate_kapusta_source(source, path)
+        return validate_macro_module_source(source, path) if macro_module_path?(path)
+
+        Kapusta::Compiler.compile(source, path:)
+      end
+
+      def validate_macro_module_source(source, path)
+        forms = Reader.read_all(source)
+        raise Error, 'macro module has no export table' unless forms.last.is_a?(HashLit)
+
+        processed = forms.map do |form|
+          Compiler::MacroLowerer.lower_module_form(form, error_class: Error)
+        end
+        wrapper = List.new([List.new([Sym.new('fn'), Vec.new([]), *processed])])
+        Compiler.compile_forms([wrapper], path:)
+      rescue Kapusta::Error => e
+        raise e.with_defaults(path:)
+      end
+
+      def macro_module_path?(path)
+        path && File.extname(path) == '.kapm'
+      end
+    end
+  end
+end