kapusta 0.3.0 → 0.5.0

data/lib/kapusta/formatter.rb

@@ -27,7 +27,8 @@ module Kapusta
 
       formatted = @files.map do |path|
         original = read_source(path)
-        [path, original, format_source(original)]
+        validate_kapusta_source(original, path)
+        [path, original, format_source(original, path)]
       end
 
       case @mode
@@ -48,13 +49,17 @@ module Kapusta
       end
 
       0
-    rescue Error => e
-      warn e.message
+    rescue Kapusta::Error => e
+      warn e.formatted
       1
     end
 
     private
 
+    def validate_kapusta_source(source, path)
+      Kapusta::Compiler.compile(source, path:)
+    end
+
     def parse_args(argv)
       argv.each do |arg|
         case arg
@@ -99,7 +104,7 @@ module Kapusta
       $stdin.read
     end
 
-    def format_source(source)
+    def format_source(source, path = nil)
       forms = Reader.read_all(source, preserve_comments: true)
       entries = top_level_entries(forms)
       return '' if entries.empty?
@@ -110,40 +115,39 @@ module Kapusta
         output << render_top_level_entry(entry)
       end
       output << "\n"
+    rescue Kapusta::Error => e
+      raise e.with_defaults(path:)
     rescue StandardError => e
-      raise Error, e.message
+      raise Error.new(e.message, path:)
     end
 
-    def separator_for(previous, current)
-      if consecutive_requires?(previous, current) ||
-         (groupable_top_level_form?(previous) && groupable_top_level_form?(current))
-        "\n"
-      else
-        "\n\n"
-      end
+    def separator_for(_previous, _current)
+      "\n"
     end
 
     def top_level_entries(forms)
       entries = []
       leading_comments = []
+      pending_blank = false
 
       forms.each do |form|
-        if comment?(form)
+        if form.is_a?(BlankLine)
+          pending_blank = true
+        elsif comment?(form)
           leading_comments << form
         else
-          entries << { comments: leading_comments, form: }
+          entries << { comments: leading_comments, form:, blank_before: pending_blank }
           leading_comments = []
+          pending_blank = false
         end
       end
 
-      entries << { comments: leading_comments, form: nil } unless leading_comments.empty?
+      entries << { comments: leading_comments, form: nil, blank_before: pending_blank } unless leading_comments.empty?
       entries
     end
 
-    def separator_for_entries(previous, current)
-      return "\n" unless previous[:form] && current[:form]
-
-      separator_for(previous[:form], current[:form])
+    def separator_for_entries(_previous, current)
+      current[:blank_before] ? "\n\n" : "\n"
     end
 
     def render_top_level_entry(entry)
@@ -156,6 +160,14 @@ module Kapusta
       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 render(form, indent, layout: nil, top_level: false, force_expand: false)
       flat = flat_render(form)
       return flat if !force_expand && flat && fits?(flat, indent) && allow_flat?(form, top_level:, layout:)
@@ -165,30 +177,65 @@ module Kapusta
       when List then render_list(form, indent, top_level:)
       when Vec then render_vec(form, indent, layout:, top_level:, force_expand:)
       when HashLit then render_hash(form, indent)
+      when Quasiquote then render_prefix('`', form.form, indent, force_expand:)
+      when Unquote then render_prefix(',', form.form, indent, force_expand:)
+      when UnquoteSplice then render_prefix(',@', form.form, indent, force_expand:)
       else
         flat || raise(Error, "cannot format form: #{form.inspect}")
       end
     end
 
+    def render_prefix(prefix, inner, indent, force_expand: false)
+      rendered = render(inner, indent + prefix.length, force_expand:)
+      lines = rendered.lines(chomp: true)
+      pad = ' ' * prefix.length
+      lines.each_with_index.map { |line, i| i.zero? ? "#{prefix}#{line}" : "#{pad}#{line}" }.join("\n")
+    end
+
     def flat_render(form)
       case form
       when Comment
         nil
+      when AutoGensym
+        "#{form.name}#"
       when Sym
         form.name
       when Vec
         return if contains_comments?(form.items)
+        return if multiline_in_source?(form)
+
+        rendered = form.items.map { |item| flat_render(item) }
+        return if rendered.any?(&:nil?)
 
-        "[#{form.items.map { |item| flat_render(item) }.join(' ')}]"
+        "[#{rendered.join(' ')}]"
       when HashLit
         return if contains_comments?(form.entries)
+        return if multiline_in_source?(form)
+
+        rendered = form.pairs.map { |key, value| flat_hash_pair(key, value) }
+        return if rendered.any?(&:nil?)
 
-        "{#{form.pairs.map { |key, value| flat_hash_pair(key, value) }.join(' ')}}"
+        "{#{rendered.join(' ')}}"
       when List
         return if contains_comments?(form.items)
         return "##{flat_render(semantic_items(form.items)[1])}" if hashfn_literal?(form)
-
-        "(#{form.items.map { |item| flat_render(item) }.join(' ')})"
+        return if multiline_in_source?(form)
+        return if let_with_multiple_bindings?(form)
+        return if let_with_nested_binding_value?(form)
+
+        rendered = form.items.map { |item| flat_render(item) }
+        return if rendered.any?(&:nil?)
+
+        "(#{rendered.join(' ')})"
+      when Quasiquote
+        inner = flat_render(form.form)
+        inner ? "`#{inner}" : nil
+      when Unquote
+        inner = flat_render(form.form)
+        inner ? ",#{inner}" : nil
+      when UnquoteSplice
+        inner = flat_render(form.form)
+        inner ? ",@#{inner}" : nil
       when String, Numeric, true, false, nil
         form.inspect
       when Symbol
@@ -207,7 +254,7 @@ module Kapusta
       raw_args = list_raw_rest(list)
 
       case head_name
-      when 'fn', 'lambda', 'λ' then render_fn(head_name, list, indent, top_level:)
+      when 'fn', 'lambda', 'λ', 'macro' then render_fn(head_name, list, indent, top_level:)
       when 'let' then render_let(list, indent)
       when 'do', 'finally' then render_prefix_body_form(head_name, [], raw_args, indent)
       when 'try' then render_try(list, indent)
@@ -237,7 +284,12 @@ module Kapusta
       raw_args = list_raw_rest(list)
       prefix_length = args[0].is_a?(Sym) && args[1].is_a?(Vec) ? 2 : 1
       raw_prefix, raw_body = split_raw_items(raw_args, prefix_length)
-      render_prefix_body_form(head, raw_prefix, raw_body, indent, force_body_multiline: top_level)
+      force = top_level || fn_body_has_quasi_list?(raw_body)
+      render_prefix_body_form(head, raw_prefix, raw_body, indent, force_body_multiline: force)
+    end
+
+    def fn_body_has_quasi_list?(body_forms)
+      body_forms.any? { |form| form.is_a?(Quasiquote) && form.form.is_a?(List) }
     end
 
     def render_catch(list, indent)
@@ -300,6 +352,35 @@ module Kapusta
       append_suffix(lines, ')')
     end
 
+    def append_prefix_form(lines, form, indent, current_first_line, inline_prefix, layouts, layout_index)
+      if blank_line?(form)
+        lines << ''
+        return [current_first_line, false, layout_index]
+      end
+      if comment?(form)
+        lines << indent_block(render(form, indent + INDENT), INDENT)
+        return [current_first_line, false, layout_index]
+      end
+
+      rendered = render(form, indent + current_first_line.length + 1, layout: layouts[layout_index])
+      rendered_lines = rendered.lines.map(&:chomp)
+      candidate_first = "#{current_first_line} #{rendered_lines.first}"
+
+      if inline_prefix && fits?(candidate_first, indent)
+        lines[-1] = candidate_first
+        if rendered_lines.length == 1
+          [candidate_first, true, layout_index + 1]
+        else
+          hanging = ' ' * (current_first_line.length + 1)
+          rendered_lines.drop(1).each { |line| lines << "#{hanging}#{line}" }
+          [current_first_line, false, layout_index + 1]
+        end
+      else
+        lines << indent_block(rendered, INDENT)
+        [current_first_line, false, layout_index + 1]
+      end
+    end
+
     def render_prefix_body_form(head, prefix_forms, body_forms, indent, layouts: [], force_body_multiline: false)
       line = "(#{head}"
       lines = [line]
@@ -308,26 +389,15 @@ module Kapusta
       inline_prefix = true
 
       prefix_forms.each do |form|
-        if comment?(form)
-          lines << indent_block(render(form, indent + INDENT), INDENT)
-          inline_prefix = false
-          next
-        end
-
-        rendered = render(form, indent + INDENT, layout: layouts[layout_index])
-        layout_index += 1
-        candidate = "#{current_first_line} #{rendered}"
-
-        if inline_prefix && single_line?(rendered) && fits?(candidate, indent)
-          current_first_line = candidate
-          lines[0] = current_first_line
-        else
-          lines << indent_block(rendered, INDENT)
-          inline_prefix = false
-        end
+        current_first_line, inline_prefix, layout_index =
+          append_prefix_form(lines, form, indent, current_first_line, inline_prefix, layouts, layout_index)
       end
 
       body_forms.each do |form|
+        if blank_line?(form)
+          lines << ''
+          next
+        end
         if comment?(form)
           lines << indent_block(render(form, indent + INDENT), INDENT)
           next
@@ -356,8 +426,8 @@ module Kapusta
         return flat if inline_three_arg_if?(args) && flat && fits?(flat, indent)
 
         lines << "(if #{render(args[0], indent + '(if '.length)}"
-        lines << "#{hanging}#{render(args[1], indent + '(if '.length)}"
-        lines << "#{hanging}#{render(args[2], indent + '(if '.length)}"
+        lines << prefix_continuation(hanging, render(args[1], indent + '(if '.length))
+        lines << prefix_continuation(hanging, render(args[2], indent + '(if '.length))
         return append_suffix(lines, ')')
       end
 
@@ -368,7 +438,7 @@ module Kapusta
           lines << "(if #{first_pair}"
         else
           lines << "(if #{render(args[0], indent + '(if '.length)}"
-          lines << "#{hanging}#{render(args[1], indent + '(if '.length)}"
+          lines << prefix_continuation(hanging, render(args[1], indent + '(if '.length))
         end
         index = 2
       else
@@ -382,12 +452,12 @@ module Kapusta
           if pair
             lines << "#{hanging}#{pair}"
           else
-            lines << "#{hanging}#{render(args[index], indent + '(if '.length)}"
-            lines << "#{hanging}#{render(args[index + 1], indent + '(if '.length)}"
+            lines << prefix_continuation(hanging, render(args[index], indent + '(if '.length))
+            lines << prefix_continuation(hanging, render(args[index + 1], indent + '(if '.length))
           end
           index += 2
         else
-          lines << "#{hanging}#{render(args[index], indent + '(if '.length)}"
+          lines << prefix_continuation(hanging, render(args[index], indent + '(if '.length))
           index += 1
         end
       end
@@ -395,6 +465,12 @@ module Kapusta
       append_suffix(lines, ')')
     end
 
+    def prefix_continuation(prefix, rendered)
+      first_line, *rest = rendered.lines(chomp: true)
+      pad = ' ' * prefix.length
+      ["#{prefix}#{first_line}", *rest.map { |line| "#{pad}#{line}" }].join("\n")
+    end
+
     def render_case(head, args, indent)
       subject = args.first
       clauses = args.drop(1)
@@ -505,15 +581,44 @@ module Kapusta
       flat = flat_render(vec)
       return flat if !force_expand && flat && fits?(flat, indent) && allow_flat?(vec, top_level:, layout:)
 
-      if layout == :pairwise && !contains_comments?(vec.items)
-        render_pairwise_vec(vec, indent)
-      else
-        lines = ['[']
-        vec.items.each do |item|
-          lines << indent_block(render(item, indent + INDENT), INDENT)
+      return render_pairwise_vec(vec, indent) if layout == :pairwise && !contains_comments?(vec.items)
+      return render_filled_vec(vec, indent) if !contains_comments?(vec.items) && !vec.items.empty?
+
+      lines = ['[']
+      vec.items.each do |item|
+        lines << indent_block(render(item, indent + INDENT), INDENT)
+      end
+      append_suffix(lines, ']')
+    end
+
+    def render_filled_vec(vec, indent)
+      output_lines = ['[']
+
+      vec.items.each_with_index do |item, idx|
+        if idx.zero?
+          item_col = output_lines.last.length
+          rendered_lines = render(item, indent + item_col).lines.map(&:chomp)
+          output_lines[-1] += rendered_lines.first
+          rendered_lines.drop(1).each { |line| output_lines << ((' ' * item_col) + line) }
+          next
+        end
+
+        inline_col = output_lines.last.length + 1
+        flat = flat_render(item)
+
+        if flat && indent + inline_col + flat.length <= MAX_WIDTH
+          output_lines[-1] += " #{flat}"
+        elsif flat && indent + 1 + flat.length <= MAX_WIDTH
+          output_lines << " #{flat}"
+        else
+          rendered_lines = render(item, indent + inline_col).lines.map(&:chomp)
+          output_lines[-1] += " #{rendered_lines.first}"
+          rendered_lines.drop(1).each { |line| output_lines << ((' ' * inline_col) + line) }
         end
-        append_suffix(lines, ']')
       end
+
+      output_lines[-1] += ']'
+      output_lines.join("\n")
     end
 
     def render_pairwise_vec(vec, indent)
@@ -567,33 +672,45 @@ module Kapusta
     def render_hash(hash, indent)
       flat = flat_render(hash)
       return flat if flat && fits?(flat, indent)
+      return '{}' if hash.entries.empty?
 
-      lines = ['{']
+      output_lines = []
 
-      hash.entries.each do |entry|
+      hash.entries.each_with_index do |entry, idx|
         if comment?(entry)
-          lines << indent_block(render(entry, indent + INDENT), INDENT)
-        else
-          key, value = entry
-          pair = flat_hash_pair(key, value)
-          if pair && fits?(pair, indent + INDENT)
-            lines << indent_block(pair, INDENT)
-          else
-            lines << indent_block(render_hash_key(key), INDENT)
-            lines << indent_block(render(value, indent + INDENT), INDENT)
-          end
+          output_lines << "#{idx.zero? ? '{' : ' '}#{render(entry, indent + 1)}"
+          next
+        end
+
+        key, value = entry
+        first_pair = output_lines.empty?
+        if hash_shorthand?(key, value)
+          output_lines << "#{first_pair ? '{' : ' '}: #{value.name}"
+          next
         end
+
+        key_str = render_hash_key(key)
+        value_col = indent + 1 + key_str.length + 1
+        rendered_value = render(value, value_col)
+        value_lines = rendered_value.lines(chomp: true)
+
+        prefix = "#{first_pair ? '{' : ' '}#{key_str} "
+        output_lines << "#{prefix}#{value_lines.first}"
+        pad = ' ' * prefix.length
+        value_lines.drop(1).each { |line| output_lines << "#{pad}#{line}" }
       end
 
-      append_suffix(lines, '}')
+      output_lines[-1] = "#{output_lines[-1]}}"
+      output_lines.join("\n")
     end
 
     def flat_hash_pair(key, value)
-      if hash_shorthand?(key, value)
-        ": #{value.name}"
-      else
-        "#{render_hash_key(key)} #{flat_render(value)}"
-      end
+      return ": #{value.name}" if hash_shorthand?(key, value)
+
+      rendered_value = flat_render(value)
+      return unless rendered_value
+
+      "#{render_hash_key(key)} #{rendered_value}"
     end
 
     def render_hash_key(key)
@@ -642,16 +759,17 @@ module Kapusta
         items[0].name == 'hashfn'
     end
 
-    def allow_flat?(form, top_level:, layout:)
+    def allow_flat?(form, top_level: false, layout: nil)
       return false if layout == :pairwise && form.is_a?(Vec) && semantic_items(form.items).length > 2
       return true unless form.is_a?(List)
+      return true if !multiline_in_source?(form) && form.respond_to?(:multiline_source)
 
       head = list_head(form)
       return true unless head.is_a?(Sym)
 
       case head.name
-      when 'fn', 'lambda', 'λ', 'when', 'unless', 'for', 'each', 'icollect', 'collect', 'fcollect', 'accumulate',
-           'faccumulate'
+      when 'fn', 'lambda', 'λ', 'macro', 'when', 'unless', 'for', 'each', 'icollect', 'collect', 'fcollect',
+           'accumulate', 'faccumulate'
         !top_level
       else
         !%w[let case match try catch finally do -> ->> -?> -?>> doto].include?(head.name)
@@ -659,14 +777,16 @@ module Kapusta
     end
 
     def force_multiline_body?(form)
+      return force_multiline_body?(form.form) if form.is_a?(Quasiquote)
       return false unless form.is_a?(List)
+      return true if multiline_in_source?(form)
 
       head = list_head(form)
       return false unless head.is_a?(Sym)
 
       case head.name
       when 'if', 'case', 'match', 'let', 'try', 'catch', 'finally', 'do', 'for', '->', '->>', '-?>', '-?>>', 'doto',
-           'fn', 'lambda', 'λ'
+           'fn', 'lambda', 'λ', 'macro'
         true
       else
         flat = flat_render(form)
@@ -674,27 +794,43 @@ module Kapusta
       end
     end
 
-    def consecutive_requires?(previous, current)
-      require_form?(previous) && require_form?(current)
+    def multiline_in_source?(form)
+      form.respond_to?(:multiline_source) && form.multiline_source
     end
 
-    def groupable_top_level_form?(form)
-      return true if require_form?(form)
-      return false unless form.is_a?(List) && flat_render(form)
+    def let_with_multiple_bindings?(form)
+      head = list_head(form)
+      return false unless head.is_a?(Sym) && head.name == 'let'
+
+      bindings = semantic_items(form.items)[1]
+      return false unless bindings.is_a?(Vec)
+
+      semantic_items(bindings.items).length > 2
+    end
 
+    def let_with_nested_binding_value?(form)
       head = list_head(form)
-      return false unless head.is_a?(Sym)
+      return false unless head.is_a?(Sym) && head.name == 'let'
+
+      bindings = semantic_items(form.items)[1]
+      return false unless bindings.is_a?(Vec)
 
-      !%w[fn module class let].include?(head.name)
+      semantic_items(bindings.items).each_slice(2).any? do |_pattern, value|
+        value && contains_collection?(value)
+      end
     end
 
-    def require_form?(form)
-      return false unless form.is_a?(List)
+    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
 
-      items = semantic_items(form.items)
-      items.length == 2 &&
-        items[0].is_a?(Sym) &&
-        items[0].name == 'require'
+    def collection?(form)
+      form.is_a?(List) || form.is_a?(Vec) || form.is_a?(HashLit)
     end
 
     def fn_form?(form)
@@ -784,11 +920,11 @@ module Kapusta
     end
 
     def contains_comments?(items)
-      items.any? { |item| comment?(item) }
+      items.any? { |item| non_semantic?(item) }
     end
 
     def semantic_items(items)
-      items.reject { |item| comment?(item) }
+      items.reject { |item| non_semantic?(item) }
     end
 
     def list_head(list)