Fix all RuboCop offenses

- Use push() instead of concat([]) for ARABIC_MARKS
- Rename cp parameter to codepoint (min 3 chars)
- Use Array#include? instead of || comparison
- Use .positive? instead of > 0
- Fix spec: use all() matcher, to_not, single quotes, parentheses
- Add trailing commas for multiline arrays

Author: alghanim

lib/prawn/text/arabic_shaping.rb

@@ -124,13 +124,13 @@ module ArabicShaping
       }.freeze
 
       # Arabic diacritical marks (tashkeel) - transparent to joining
-      ARABIC_MARKS = (0x064B..0x065F).to_a.concat(
-        [0x0610, 0x0611, 0x0612, 0x0613, 0x0614, 0x0615,
-         0x0616, 0x0617, 0x0618, 0x0619, 0x061A,
-         0x06D6, 0x06D7, 0x06D8, 0x06D9, 0x06DA, 0x06DB,
-         0x06DC, 0x06DF, 0x06E0, 0x06E1, 0x06E2, 0x06E3,
-         0x06E4, 0x06E7, 0x06E8, 0x06EA, 0x06EB, 0x06EC, 0x06ED,
-         0x0670]
+      ARABIC_MARKS = (0x064B..0x065F).to_a.push(
+        0x0610, 0x0611, 0x0612, 0x0613, 0x0614, 0x0615,
+        0x0616, 0x0617, 0x0618, 0x0619, 0x061A,
+        0x06D6, 0x06D7, 0x06D8, 0x06D9, 0x06DA, 0x06DB,
+        0x06DC, 0x06DF, 0x06E0, 0x06E1, 0x06E2, 0x06E3,
+        0x06E4, 0x06E7, 0x06E8, 0x06EA, 0x06EB, 0x06EC, 0x06ED,
+        0x0670,
       ).freeze
 
       ARABIC_MARKS_SET = ARABIC_MARKS.to_set.freeze
@@ -178,34 +178,34 @@ def shape(text)
 
         private
 
-        def arabic_letter?(cp)
-          ARABIC_FORMS.key?(cp)
+        def arabic_letter?(codepoint)
+          ARABIC_FORMS.key?(codepoint)
         end
 
-        def arabic_mark?(cp)
-          ARABIC_MARKS_SET.include?(cp)
+        def arabic_mark?(codepoint)
+          ARABIC_MARKS_SET.include?(codepoint)
         end
 
-        def dual_joining?(cp)
-          forms = ARABIC_FORMS[cp]
+        def dual_joining?(codepoint)
+          forms = ARABIC_FORMS[codepoint]
           forms && forms[2] && forms[3]
         end
 
-        def right_joining?(cp)
-          forms = ARABIC_FORMS[cp]
+        def right_joining?(codepoint)
+          forms = ARABIC_FORMS[codepoint]
           forms && forms[1] && !forms[2]
         end
 
-        def join_causing?(cp)
-          cp == 0x0640 || cp == 0x200D
+        def join_causing?(codepoint)
+          [0x0640, 0x200D].include?(codepoint)
         end
 
-        def can_join_right?(cp)
-          dual_joining?(cp) || right_joining?(cp) || join_causing?(cp)
+        def can_join_right?(codepoint)
+          dual_joining?(codepoint) || right_joining?(codepoint) || join_causing?(codepoint)
         end
 
-        def can_join_left?(cp)
-          dual_joining?(cp) || join_causing?(cp)
+        def can_join_left?(codepoint)
+          dual_joining?(codepoint) || join_causing?(codepoint)
         end
 
         def shape_run(run)
@@ -232,7 +232,7 @@ def shape_run(run)
             else
               forms = ARABIC_FORMS[entry]
               if forms
-                prev_joins = idx > 0 && prev_can_join_left?(shaped_bases, idx)
+                prev_joins = idx.positive? && prev_can_join_left?(shaped_bases, idx)
                 next_joins = idx < shaped_bases.length - 1 && next_can_join_right?(shaped_bases, idx)
                 result << select_form(forms, prev_joins, next_joins)
               else
@@ -254,7 +254,7 @@ def apply_lam_alef_ligatures(bases)
             if bases[i] == 0x0644 && i + 1 < bases.length && LAM_ALEF_LIGATURES.key?(bases[i + 1])
               alef = bases[i + 1]
               ligature_forms = LAM_ALEF_LIGATURES[alef]
-              prev_joins = i > 0 && can_join_left?(bases[i - 1])
+              prev_joins = i.positive? && can_join_left?(bases[i - 1])
               ligature_cp = prev_joins ? ligature_forms[1] : ligature_forms[0]
               result << [ligature_cp, prev_joins ? :final : :isolated]
               i += 2

spec/prawn/text/arabic_shaping_spec.rb

@@ -5,25 +5,28 @@
 RSpec.describe Prawn::Text::ArabicShaping do
   describe '.contains_arabic?' do
     it 'returns true for Arabic text' do
-      expect(described_class.contains_arabic?('مرحبا')).to be true
+      expect(described_class.contains_arabic?('مرحبا')).to be(true)
     end
 
     it 'returns false for Latin text' do
-      expect(described_class.contains_arabic?('Hello')).to be false
+      expect(described_class.contains_arabic?('Hello')).to be(false)
     end
 
     it 'returns true for mixed Arabic/Latin text' do
-      expect(described_class.contains_arabic?('Hello مرحبا')).to be true
+      expect(described_class.contains_arabic?('Hello مرحبا')).to be(true)
     end
 
     it 'returns false for empty string' do
-      expect(described_class.contains_arabic?('')).to be false
+      expect(described_class.contains_arabic?('')).to be(false)
     end
   end
 
   describe '.shape' do
-    it 'returns nil/empty unchanged' do
+    it 'returns nil unchanged' do
       expect(described_class.shape(nil)).to be_nil
+    end
+
+    it 'returns empty string unchanged' do
       expect(described_class.shape('')).to eq('')
     end
 
@@ -33,67 +36,59 @@
 
     it 'converts Arabic characters to presentation forms' do
       shaped = described_class.shape('مرحبا')
-      # All characters should be in the Arabic Presentation Forms range
-      shaped.codepoints.each do |cp|
-        expect(cp).to be_between(0xFE70, 0xFEFF)
-          .or be_between(0xFB50, 0xFDFF)
-      end
+      expect(shaped.codepoints).to all(
+        be_between(0xFE70, 0xFEFF).or(be_between(0xFB50, 0xFDFF)),
+      )
     end
 
     it 'shapes initial form correctly' do
-      # م at the start of مرحبا should be initial form (FEE3)
       shaped = described_class.shape('مرحبا')
-      expect(shaped.codepoints.first).to eq(0xFEE3) # MEEM INITIAL
+      expect(shaped.codepoints.first).to eq(0xFEE3)
     end
 
     it 'shapes final form correctly' do
-      # ا at the end of مرحبا should be final form (FE8E)
       shaped = described_class.shape('مرحبا')
-      expect(shaped.codepoints.last).to eq(0xFE8E) # ALEF FINAL (via ALEF MAKSURA)
+      expect(shaped.codepoints.last).to eq(0xFE8E)
     end
 
     it 'shapes medial form correctly' do
-      # ح in مرحبا should be medial form (FEA4)
       shaped = described_class.shape('مرحبا')
-      expect(shaped.codepoints[2]).to eq(0xFEA3) # HAH MEDIAL
+      expect(shaped.codepoints[2]).to eq(0xFEA3)
     end
 
     it 'shapes isolated characters correctly' do
-      shaped = described_class.shape('ء') # HAMZA - always isolated
+      shaped = described_class.shape('ء')
       expect(shaped.codepoints.first).to eq(0xFE80)
     end
 
-    it 'handles right-joining characters (Alef, Dal, etc.)' do
-      # Alef only joins to the right
-      shaped = described_class.shape('با') # BEH + ALEF
+    it 'handles right-joining characters' do
+      shaped = described_class.shape('با')
       cps = shaped.codepoints
-      expect(cps[0]).to eq(0xFE91) # BEH INITIAL
-      expect(cps[1]).to eq(0xFE8E) # ALEF FINAL
+      expect(cps[0]).to eq(0xFE91)
+      expect(cps[1]).to eq(0xFE8E)
     end
 
     it 'creates Lam-Alef ligatures' do
       shaped = described_class.shape('لا')
-      expect(shaped.codepoints).to eq([0xFEFB]) # LAM-ALEF ISOLATED
+      expect(shaped.codepoints).to eq([0xFEFB])
     end
 
     it 'creates Lam-Alef ligature in final form when preceded' do
-      shaped = described_class.shape('بلا') # BEH + LAM + ALEF
+      shaped = described_class.shape('بلا')
       cps = shaped.codepoints
-      expect(cps[0]).to eq(0xFE91) # BEH INITIAL
-      expect(cps[1]).to eq(0xFEFC) # LAM-ALEF FINAL
+      expect(cps[0]).to eq(0xFE91)
+      expect(cps[1]).to eq(0xFEFC)
     end
 
     it 'creates Lam-Alef with Madda ligature' do
-      shaped = described_class.shape("ل\u0622") # LAM + ALEF WITH MADDA
+      shaped = described_class.shape("\u0644\u0622")
       expect(shaped.codepoints).to eq([0xFEF5])
     end
 
     it 'preserves diacritical marks' do
-      text = "بِسْمِ" # with kasra and sukun
-      shaped = described_class.shape(text)
-      # Marks should still be present
-      marks = shaped.codepoints.select { |cp| (0x064B..0x065F).cover?(cp) }
-      expect(marks).not_to be_empty
+      shaped = described_class.shape("\u0628\u0650\u0633\u0652\u0645\u0650")
+      marks = shaped.codepoints.select { |codepoint| (0x064B..0x065F).cover?(codepoint) }
+      expect(marks).to_not be_empty
     end
 
     it 'preserves spaces between words' do
@@ -105,29 +100,27 @@
       shaped = described_class.shape('Hello مرحبا World')
       expect(shaped).to include('Hello')
       expect(shaped).to include('World')
-      # Arabic part should be shaped
-      expect(shaped).not_to include('م') # original meem should be replaced
+      expect(shaped).to_not include('م')
     end
 
-    it 'handles Tatweel (kashida)' do
-      shaped = described_class.shape("بـا") # BEH + TATWEEL + ALEF
-      cps = shaped.codepoints
-      expect(cps).to include(0x0640) # TATWEEL preserved
+    it 'handles Tatweel' do
+      shaped = described_class.shape("\u0628\u0640\u0627")
+      expect(shaped.codepoints).to include(0x0640)
     end
 
     it 'shapes Farsi Yeh correctly' do
-      shaped = described_class.shape("\u06CC") # FARSI YEH isolated
-      expect(shaped.codepoints.first).to eq(0xFBFC) # FARSI YEH ISOLATED
+      shaped = described_class.shape("\u06CC")
+      expect(shaped.codepoints.first).to eq(0xFBFC)
     end
 
-    it 'shapes Peh correctly (Urdu/Farsi)' do
-      shaped = described_class.shape("\u067E") # PEH isolated
-      expect(shaped.codepoints.first).to eq(0xFB56) # PEH ISOLATED
+    it 'shapes Peh correctly' do
+      shaped = described_class.shape("\u067E")
+      expect(shaped.codepoints.first).to eq(0xFB56)
     end
 
-    it 'shapes Gaf correctly (Farsi)' do
-      shaped = described_class.shape("\u06AF") # GAF isolated
-      expect(shaped.codepoints.first).to eq(0xFB92) # GAF ISOLATED
+    it 'shapes Gaf correctly' do
+      shaped = described_class.shape("\u06AF")
+      expect(shaped.codepoints.first).to eq(0xFB92)
     end
   end
 end