code-ruby 3.0.11 → 3.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb5a51861ed784ebc8e0fbd2e6e6232ee05a3f3bafbc4f150e5cc92236590254
-  data.tar.gz: b2a82b40b6740387fde8490e5054cc1a0ab5d39c34e2ce7a694421cf5e0852ed
+  metadata.gz: eef80c2ebc4ef6d318ee0af151704caca0f0a370c698dc727814836d6e5146db
+  data.tar.gz: 6ac8ae69e473aa937eb4794466e710ec40444c53f5d1a12149368e03de0bc4c0
 SHA512:
-  metadata.gz: ca94cf8211ff117ca68db85a48d876a28f857398996b327a88a6488931d29bbdda34bc6d1b893af9196ecc25735a83875533f099cecbc15b5c9ffd248e34d0df
-  data.tar.gz: 9ecf7d03fffb87b1d7ade9242bc0cc4e75a8ff04b31c57b3c05cb2caba5811c1cb567de362e0c95c5852b2bebc3794df6291adb773b8b4a13da0c7320df03b3f
+  metadata.gz: 6b99011ea5c71b86b7709949e2d4096f4708b2a4c985e1f30e704bac060c58c710922797c4c4ade47f91b31ad37a47153f66fd8e204783786d55da38234e0d79
+  data.tar.gz: 367d671e1fbb4aaacd278bd3e186a03a7304f7041f5381e502a54e44afe754048ed603eb83e6e21f2c8415916078b633fc352984ae6c5b4ab27f96c330394b19

data/Gemfile.lock

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

data/VERSION

@@ -1 +1 @@
-3.0.11
+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,7 +438,7 @@ class Code
 
         expression =
           if compact_operator?(operator)
-            "#{expression}#{operator}#{right}"
+            "#{format_compact_receiver(expression, indent: indent)}#{operator}#{right}"
           else
             candidate = "#{expression} #{operator} #{right}"
             if right.include?("\n")
@@ -449,8 +456,10 @@ class Code
               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|
@@ -469,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)
 
@@ -496,8 +533,14 @@ 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
@@ -512,6 +555,42 @@ class Code
       "#{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
@@ -519,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
 
@@ -654,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)

data/spec/code/format_spec.rb

@@ -58,16 +58,34 @@ RSpec.describe Code::Format do
       ],
       [
         "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 (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\"))"
+        "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
@@ -77,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.11
+  version: 3.0.12
 platform: ruby
 authors:
 - Dorian Marié