code-ruby 3.0.10 → 3.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e59505a1d473ed64e03853dd3465ce958bb81ee2dfcd2ec38b0280a5ee3dd98a
-  data.tar.gz: e13a2d15ba45209e81213bd7b5a3f1ea58a26cdcb9446f29f9f6b5906aa7e9fe
+  metadata.gz: eef80c2ebc4ef6d318ee0af151704caca0f0a370c698dc727814836d6e5146db
+  data.tar.gz: 6ac8ae69e473aa937eb4794466e710ec40444c53f5d1a12149368e03de0bc4c0
 SHA512:
-  metadata.gz: 82cf388eb36848ff8f01f122177e436205ccebfd6f4e19488e65e1adecdff267246292da159a99b42cca23f5adefb505483ebe1357b928922ee824ac4c832086
-  data.tar.gz: 3069cb6a421189bad2b0aba4eed4a3d50d5e24128f1fcd6fa6ee12db5110b5a53babf2b310175ba4701b59a5bb3447bb4fd1505282c5f3de44c5e2c3a530fc6d
+  metadata.gz: 6b99011ea5c71b86b7709949e2d4096f4708b2a4c985e1f30e704bac060c58c710922797c4c4ade47f91b31ad37a47153f66fd8e204783786d55da38234e0d79
+  data.tar.gz: 367d671e1fbb4aaacd278bd3e186a03a7304f7041f5381e502a54e44afe754048ed603eb83e6e21f2c8415916078b633fc352984ae6c5b4ab27f96c330394b19

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    code-ruby (3.0.10)
+    code-ruby (3.0.12)
       activesupport
       base64
       bigdecimal

data/VERSION

@@ -1 +1 @@
-3.0.10
+3.0.12

data/lib/code/format.rb

@@ -57,13 +57,20 @@ class Code
       "begin\n#{body}\n#{INDENT * indent}end"
     end
 
+    def format_group(group, indent:)
+      formatted = format_code_inline(group, indent: indent)
+      return "(#{formatted})" unless formatted.include?("\n")
+
+      "(\n#{indent_lines(normalize_group_indentation(formatted, indent: indent), indent + 1)}\n#{INDENT * indent})"
+    end
+
     def format_statement(statement, indent:)
       if statement.is_a?(Hash) && statement.key?(:nothing)
         statement[:nothing].presence || "nothing"
       elsif statement.is_a?(Hash) && statement.key?(:boolean)
         statement[:boolean]
       elsif statement.is_a?(Hash) && statement.key?(:group)
-        "(#{format_code_inline(statement[:group], indent: indent)})"
+        format_group(statement[:group], indent: indent)
       elsif statement.is_a?(Hash) && statement.key?(:call)
         format_call(statement[:call], indent: indent)
       elsif statement.is_a?(Hash) && statement.key?(:number)
@@ -431,19 +438,28 @@ class Code
 
         expression =
           if compact_operator?(operator)
-            "#{expression}#{operator}#{right}"
+            "#{format_compact_receiver(expression, indent: indent)}#{operator}#{right}"
           else
             candidate = "#{expression} #{operator} #{right}"
-            if multiline_collection_statement?(other[:statement]) &&
-                 right.include?("\n")
+            if right.include?("\n")
               first_line, *rest = right.lines(chomp: true)
-              [ "#{expression} #{operator} #{first_line}", *rest ].join("\n")
+              if multiline_operand_statement?(other[:statement]) ||
+                   !%w[and or].include?(operator)
+                [ "#{expression} #{operator} #{first_line.lstrip}", *rest ].join("\n")
+              else
+                [
+                  "#{expression}\n#{INDENT * (indent + 1)}#{operator} #{first_line.lstrip}",
+                  *rest
+                ].join("\n")
+              end
             elsif expression.include?("\n") || candidate.length > MAX_LINE_LENGTH
               right_lines =
                 if right.include?("\n")
                   right.lines(chomp: true).map(&:lstrip)
-                else
+                elsif %w[and or].include?(operator)
                   right.split(" #{operator} ")
+                else
+                  [right]
                 end
               continuation_lines =
                 right_lines.map do |line|
@@ -462,6 +478,34 @@ class Code
       expression
     end
 
+    def format_compact_receiver(expression, indent:)
+      return expression unless compact_receiver_needs_parentheses?(expression)
+
+      "(\n#{indent_lines(expression, indent + 1)}\n#{INDENT * indent})"
+    end
+
+    def compact_receiver_needs_parentheses?(expression)
+      return false unless expression.include?("\n")
+      return false if expression.lstrip.start_with?("(")
+
+      continuation_lines =
+        expression
+          .lines(chomp: true)[1..]
+          .to_a
+          .reject { |line| line.strip.empty? || line.strip.match?(/\A[\)\]\}]+\z/) }
+
+      return false if continuation_lines.empty?
+
+      base_indent =
+        continuation_lines.map { |line| line[/\A */].to_s.length }.min
+
+      continuation_lines.any? do |line|
+        next false unless line[/\A */].to_s.length == base_indent
+
+        line.lstrip.match?(/\A(\+|-|\*|\/|%|<<|>>|\||\^|&|and\b|or\b)/)
+      end
+    end
+
     def extract_string_concatenation_parts(statement)
       return nil unless statement.is_a?(Hash)
 
@@ -489,11 +533,64 @@ class Code
 
     def format_right_operation(operation, indent:)
       operator = operation[:operator].to_s
-      left = format_nested_statement(operation[:left], indent: indent)
+      left =
+        if %w[if unless].include?(operator)
+          format_modifier_left(operation[:left], indent: indent)
+        else
+          format_nested_statement(operation[:left], indent: indent)
+        end
       right = format_nested_statement(operation[:right], indent: indent)
+
+      if right.include?("\n")
+        first_line, *rest = right.lines(chomp: true)
+        first_line = first_line.lstrip
+        return "#{left} #{operator} #{first_line}" if rest.empty?
+
+        return [
+          "#{left} #{operator} #{first_line}",
+          *rest
+        ].join("\n")
+      end
+
       "#{left} #{operator} #{right}"
     end
 
+    def format_modifier_left(statement, indent:)
+      if statement.is_a?(Hash) && statement.key?(:right_operation)
+        nested = statement[:right_operation]
+        nested_operator = nested[:operator].to_s
+        if nested_operator == "="
+          left = format_nested_statement(nested[:left], indent: indent)
+          right = format_nested_statement(nested[:right], indent: indent)
+          return "#{left} #{nested_operator} #{group_multiline_expression(right, indent: indent)}"
+        end
+      end
+
+      format_nested_statement(statement, indent: indent)
+    end
+
+    def group_multiline_expression(expression, indent:)
+      return expression unless expression.include?("\n")
+      return expression if expression.lstrip.start_with?("(")
+
+      normalized = normalize_group_indentation(expression, indent: indent)
+      "(\n#{indent_lines(normalized, indent + 1)}\n#{INDENT * indent})"
+    end
+
+    def normalize_group_indentation(expression, indent:)
+      prefix = INDENT * indent
+
+      expression
+        .lines(chomp: true)
+        .map
+        .with_index do |line, index|
+          next line if index.zero? || line.empty? || prefix.empty?
+
+          line.delete_prefix(prefix)
+        end
+        .join("\n")
+    end
+
     def compact_operator?(operator)
       %w[. :: &. .. ...].include?(operator)
     end
@@ -501,9 +598,11 @@ class Code
     def format_ternary(ternary, indent:)
       left = format_nested_statement(ternary[:left], indent: indent)
       middle = format_nested_statement(ternary[:middle], indent: indent)
+      middle = group_multiline_expression(middle, indent: indent)
       return "#{left} ? #{middle}" unless ternary.key?(:right)
 
       right = format_nested_statement(ternary[:right], indent: indent)
+      right = group_multiline_expression(right, indent: indent)
       "#{left} ? #{middle} : #{right}"
     end
 
@@ -598,9 +697,22 @@ class Code
       values.join(", ").length > MAX_INLINE_COLLECTION_LENGTH
     end
 
-    def multiline_collection_statement?(statement)
-      statement.is_a?(Hash) &&
-        (statement.key?(:dictionnary) || statement.key?(:list))
+    def multiline_operand_statement?(statement)
+      return false unless statement.is_a?(Hash)
+
+      return true if statement.key?(:dictionnary) || statement.key?(:list)
+      return true if statement.key?(:call)
+      if statement.key?(:left_operation)
+        operation = statement[:left_operation]
+        others = Array(operation[:others])
+
+        return false if others.empty?
+        return false unless others.all? { |other| compact_operator?(other[:operator]) }
+
+        return multiline_operand_statement?(operation[:first])
+      end
+
+      false
     end
 
     def multiline_call_arguments?(raw_arguments, arguments)
@@ -623,7 +735,7 @@ class Code
 
     def indent_lines(value, indent)
       prefix = INDENT * indent
-      value.split("\n").map { |line| "#{prefix}#{line}" }.join("\n")
+      value.split("\n").map { |line| line.empty? ? "" : "#{prefix}#{line}" }.join("\n")
     end
 
     def statement_separator(inline:, indent: nil)
@@ -692,7 +804,7 @@ class Code
       search_limit = [MAX_LINE_LENGTH, line.length - token.length].min
       index = line.rindex(token, search_limit)
       while index
-        break if index.positive? && outside_string?(line, index)
+        break if index.positive? && outside_string_and_grouping?(line, index)
 
         index = line.rindex(token, index - 1)
       end
@@ -701,9 +813,10 @@ class Code
       [index, token]
     end
 
-    def outside_string?(line, index)
+    def outside_string_and_grouping?(line, index)
       quote_count = 0
       escaped = false
+      grouping_depth = 0
       line[0...index].each_char do |char|
         if escaped
           escaped = false
@@ -714,10 +827,17 @@ class Code
           escaped = true
         elsif char == '"'
           quote_count += 1
+        elsif quote_count.even?
+          case char
+          when "(", "[", "{"
+            grouping_depth += 1
+          when ")", "]", "}"
+            grouping_depth -= 1 if grouping_depth.positive?
+          end
         end
       end
 
-      quote_count.even?
+      quote_count.even? && grouping_depth.zero?
     end
   end
 end

data/spec/code/format_spec.rb

@@ -51,11 +51,41 @@ RSpec.describe Code::Format do
       [
         "blocks << { title: \"hello world\", description: \"lorem ipsum dolor es sit\", position: 1 }",
         "blocks << {\n  title: \"hello world\",\n  description: \"lorem ipsum dolor es sit\",\n  position: 1\n}"
+      ],
+      [
+        "sections << Html.join([Html.p { Html.b { \"{index + 1}. {title}\" } }, Html.p { query } if query.presence, Html.p { Html.a(href: link || inline_url) { :source } } if (link || inline_url), Html.p { Html.a(href: inline_url) { Html.img(src: inline_url, alt: title) } }, Html.p { Html.a(href: attachment_url) { \"télécharger\" } }].compact)",
+        "sections << Html.join(\n  [\n    Html.p { Html.b { \"{index + 1}. {title}\" } },\n    Html.p { query } if query.presence,\n    Html.p {\n      Html.a(href: link || inline_url) { :source }\n    } if (link || inline_url),\n    Html.p {\n      Html.a(href: inline_url) { Html.img(src: inline_url, alt: title) }\n    },\n    Html.p {\n      Html.a(href: attachment_url) { \"télécharger\" }\n    }\n  ].compact\n)"
+      ],
+      [
+        "safe = post.present? and !post[:over_18] and post[:post_hint] == :image and post[:url].to_string.strip.presence and (post[:url].to_string.strip.ends_with?(\".jpg\") or post[:url].to_string.strip.ends_with?(\".jpeg\") or post[:url].to_string.strip.ends_with?(\".png\") or post[:url].to_string.strip.include?(\"i.redd.it\"))",
+        "safe = post.present?\n  and !post[:over_18]\n  and post[:post_hint] == :image\n  and post[:url].to_string.strip.presence\n  and (\n  post[:url].to_string.strip.ends_with?(\".jpg\")\n    or post[:url].to_string.strip.ends_with?(\".jpeg\")\n    or post[:url].to_string.strip.ends_with?(\".png\")\n    or post[:url].to_string.strip.include?(\"i.redd.it\")\n)"
+      ],
+      [
+        "items.each { |item, index| proxied_image_url = if image_url proxy_url(image_url) else nothing end }",
+        "items.each { |item, index|\n  proxied_image_url = if image_url\n    proxy_url(image_url)\n  else\n    nothing\n  end\n}"
+      ],
+      [
+        "lines << \"vacances scolaires france {zone} (prochains {months_ahead} mois) :\".downcase",
+        "lines << (\n  \"vacances scolaires france {zone} (prochains \"\n    + \"{months_ahead} mois) :\"\n).downcase"
+      ],
+      [
+        "src = \"https://proxy.dorianmarie.com?\" + \"{{ url: src, disposition: :inline }.to_query}\" if src",
+        "src = (\n  \"https://proxy.dorianmarie.com?\"\n    + \"{{ url: src, disposition: :inline }.to_query}\"\n) if src"
+      ],
+      [
+        "inline_image = image ? \"https://proxy.dorianmarie.com?\" + \"{inline_params.to_query}\" : nothing",
+        "inline_image = image ? (\n  \"https://proxy.dorianmarie.com?\"\n    + \"{inline_params.to_query}\"\n) : nothing"
       ]
     ].each do |input, expected|
       it "formats #{input.inspect}" do
         expect(described_class.format(Code.parse(input))).to eq(expected)
       end
+
+      it "formats #{input.inspect} idempotently" do
+        formatted = described_class.format(Code.parse(input))
+
+        expect(described_class.format(Code.parse(formatted))).to eq(formatted)
+      end
     end
 
     it "round-trips parse and evaluation semantics for formatted code" do
@@ -65,5 +95,50 @@ RSpec.describe Code::Format do
       expect(Code.parse(formatted)).to be_present
       expect(Code.evaluate(formatted)).to eq(Code.evaluate(input))
     end
+
+    it "keeps grouped multiline receivers stable" do
+      input = <<~CODE.chomp
+        lines << (
+          "vacances scolaires france {zone} (prochains "
+            + "{months_ahead} mois) :"
+        ).downcase
+      CODE
+
+      expect(described_class.format(Code.parse(input))).to eq(input)
+    end
+
+    it "does not split operators inside string interpolations when wrapping" do
+      input =
+        %q(body_text = "{title}\n\n{description}\n\ningrédients :\n" + ingredients.map { |ingredient| "- {ingredient}" }.join("\n") + "\n\ninstructions :\n" + instructions.map { |instruction, index| "{index + 1}. {instruction}" }.join("\n"))
+
+      formatted = described_class.format(Code.parse(input))
+
+      expect(formatted).to include(
+        'instructions.map { |instruction, index| "{index + 1}. {instruction}" }'
+      )
+      expect(formatted).not_to include(
+        "\"{index\n  + 1}. {instruction}\""
+      )
+    end
+
+    it "does not emit whitespace-only blank lines" do
+      input = <<~CODE.chomp
+        body = Html.join(elements.map { |element| title = element.at_css(".x") value = element.at_css(".y") title }, Html.br)
+      CODE
+
+      formatted = described_class.format(Code.parse(input))
+
+      expect(formatted.lines).not_to include(match(/\A[ \t]+\n\z/))
+    end
+
+    it "keeps lines within 80 characters" do
+      input = <<~CODE.chomp
+        src = "https://proxy.dorianmarie.com?" + "{{ url: src, disposition: :inline }.to_query}" if src
+      CODE
+
+      formatted = described_class.format(Code.parse(input))
+
+      expect(formatted.lines.map(&:chomp).map(&:length).max).to be <= 80
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 3.0.10
+  version: 3.0.12
 platform: ruby
 authors:
 - Dorian Marié