code-ruby 3.0.11 → 3.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb5a51861ed784ebc8e0fbd2e6e6232ee05a3f3bafbc4f150e5cc92236590254
-  data.tar.gz: b2a82b40b6740387fde8490e5054cc1a0ab5d39c34e2ce7a694421cf5e0852ed
+  metadata.gz: 6baa3c7c3ef6b602529e2af4a36200029291ed89c115f1c1f3d750a8e815cc03
+  data.tar.gz: aa9c876fb0aff915f895ec3d209d25ac06270e3809eadba8f5e71b37b9cb29db
 SHA512:
-  metadata.gz: ca94cf8211ff117ca68db85a48d876a28f857398996b327a88a6488931d29bbdda34bc6d1b893af9196ecc25735a83875533f099cecbc15b5c9ffd248e34d0df
-  data.tar.gz: 9ecf7d03fffb87b1d7ade9242bc0cc4e75a8ff04b31c57b3c05cb2caba5811c1cb567de362e0c95c5852b2bebc3794df6291adb773b8b4a13da0c7320df03b3f
+  metadata.gz: 444adc5d9b9a5223b82a921a888558a2f23dc40344a12b383137581b910ba4e33ea13873a2e5ce6698dc130ae77775cf9aa5b3e0e23f70947418301831df96b9
+  data.tar.gz: bcf7ecebc28788a2cf7464e3a7b67f32b2bfb86ec3d6365ca58674914d852181d27f3a051b596665807acd67291c2026d227b98d33603260e3122417e04d6a76

data/Gemfile.lock

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

data/VERSION

@@ -1 +1 @@
-3.0.11
+3.0.13

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)
@@ -427,11 +434,11 @@ class Code
 
       Array(operation[:others]).each do |other|
         right = format_nested_statement(other[:statement], indent: indent)
-        operator = other[:operator]
+        operator = format_operator(other[:operator])
 
         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)
 
@@ -495,9 +532,15 @@ class Code
     end
 
     def format_right_operation(operation, indent:)
-      operator = operation[:operator].to_s
-      left = format_nested_statement(operation[:left], indent: indent)
+      operator = format_operator(operation[:operator])
+      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,16 +555,65 @@ 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
 
+    def format_operator(operator)
+      case operator.to_s
+      when "||"
+        "or"
+      when "&&"
+        "and"
+      else
+        operator.to_s
+      end
+    end
+
     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 +746,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/lib/code/object/string.rb

@@ -157,6 +157,10 @@ class Code
 
       def code_strip
         String.new(raw.strip)
+      rescue ArgumentError, Encoding::CompatibilityError => e
+        raise unless e.message.include?("invalid byte sequence")
+
+        String.new(sanitized_utf8_raw.strip)
       end
 
       def code_split(value)
@@ -172,6 +176,15 @@ class Code
       def present?
         raw.present?
       end
+
+      private
+
+      def sanitized_utf8_raw
+        raw
+          .dup
+          .force_encoding(::Encoding::UTF_8)
+          .encode(::Encoding::UTF_8, invalid: :replace, undef: :replace)
+      end
     end
   end
 end

data/spec/code/format_spec.rb

@@ -13,6 +13,8 @@ RSpec.describe Code::Format do
       %w[100000 100_000],
       %w[1000000 1_000_000],
       %w[1.0000000001 1.000_000_000_1],
+      ["true || false", "true or false"],
+      ["true && false", "true and false"],
       ["{a:1}", "{ a: 1 }"],
       ["[1,2,3]", "[1, 2, 3]"],
       ["[1, 2, 3].select { |n| n.even? }", "[1, 2, 3].select { |n| n.even? }"],
@@ -54,20 +56,38 @@ RSpec.describe Code::Format do
       ],
       [
         "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)"
+        "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 or inline_url) { :source }\n    } if (link or 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 (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 +97,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

data/spec/code/object/string_spec.rb

@@ -15,4 +15,12 @@ RSpec.describe Code::Object::String do
       expect(Code.evaluate(input).to_s).to eq(expected)
     end
   end
+
+  describe "#code_strip" do
+    it "replaces invalid utf-8 bytes instead of raising" do
+      string = described_class.new("\xC3 ".b.force_encoding(Encoding::UTF_8))
+
+      expect(string.code_strip.to_s).to eq("\uFFFD")
+    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.13
 platform: ruby
 authors:
 - Dorian Marié