textbringer 27 → 28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be4c934800d0492229b1476d4541825533ff3e824490ad23ef331926ee8d6492
-  data.tar.gz: 9157e0ba963f1dd77eab7a50f929c91b1ae6a7689c1ad41cda22876c32d6c0fb
+  metadata.gz: a93c844e10f5ad02a288323d8090d5dedea44b7f6050b054f9adc100e2bac129
+  data.tar.gz: 6a54096a278fba823491914ea9b184f1c640d64f5234192dabf64afad7ad3ce1
 SHA512:
-  metadata.gz: 3f70f40322ad8fed8ef2044839e3df7fee67922b1cfe975283516cf3a10fac6566248d0a5fbcc98ef319155302105c0c37d9f30fa602f6a3b3b2069dbf5a1314
-  data.tar.gz: 6348a9ecddb8423d4fb07b8291dcda1ce7945cf049e997770347deb309ad8c3a507bfb6815a5db2c7f277677680c4023793cf9fd221ea96bd4ed60e5863e68e6
+  metadata.gz: f19c746e74c12884bd99d827faaf0eee55a2dca803c1a2518f857286c00c91b0d7ad7d3516ce3e7e659cabd32db841674d9f42158ce01381ad9ea0b0901d71f0
+  data.tar.gz: 9aaf8575f47fd4e20bcd9cd868cad9b232bc7444fc29311c68d844058ab620d94a732b84ade0b527ee1ba2122f2a50f42981d17353de5c78f2c51c4535f24cd9

data/README.md

@@ -135,7 +135,9 @@ set_background_color "default"
 
 After checking out the repo, run `bundle install` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To run the tests, run `bundle exec rake test`. To install this gem onto your local machine, run `bundle exec rake install`.
+
+To release a new version, run `bundle exec rake bump` on a clean `main` branch. It increments the version number in `version.rb`, commits and pushes the change, and pushes a `v<N>` tag. The tag triggers the `push_gem.yml` workflow, which publishes the gem to [rubygems.org](https://rubygems.org) via trusted publishing and creates a GitHub release. Do not run `bundle exec rake release`; it would try to push the gem from your machine as well.
 
 ## Contributing
 

data/lib/textbringer/commands/fill.rb

@@ -2,32 +2,151 @@ require "stringio"
 
 module Textbringer
   module FillExtension
+    class Filler
+      GRAPH = /(?=[\u{0000}-\u{00FF}])[[:graph:]]/
+
+      def initialize(column, prefix)
+        @column = column
+        @prefix = prefix
+        @prefix_width = Buffer.display_width(prefix)
+        @fill_column = CONFIG[:fill_column]
+        @output = +""
+        @line_start = 0
+        @prev_c = nil
+        @bol = column == 0
+      end
+
+      # head is kept as it is at the start of the first line; body is the
+      # text to fill, with the prefix already removed from each line.
+      def fill(head, body)
+        if !head.empty?
+          @output << head
+          @line_start = head.size
+          @column += Buffer.display_width(head)
+          @bol = false
+        end
+        input = StringIO.new(body)
+        while c = input.getc
+          if c == "\n"
+            skip_blanks(input)
+            if input.eof?
+              insert_final_newline
+            elsif @column < @fill_column
+              if GRAPH.match?(@prev_c)
+                insert_space_between_words(input)
+              end
+              next
+            else
+              insert_newline(@prefix)
+            end
+          else
+            w = Buffer.display_width(c)
+            if @column + w > @fill_column || @column >= @fill_column
+              if /\w/.match?(@prev_c) && /\w/.match?(c)
+                insert_newline_before_word
+              else
+                insert_newline(@prefix)
+              end
+            end
+            insert_char(c, w)
+          end
+          @prev_c = c
+        end
+        @output
+      end
+
+      private
+
+      def skip_blanks(input)
+        while c = input.getc
+          if !/[ \t]/.match?(c)
+            input.ungetc(c)
+            break
+          end
+        end
+      end
+
+      def insert_space_between_words(input)
+        c = input.getc
+        input.ungetc(c)
+        if GRAPH.match?(c)
+          @output << " "
+          @column += 1
+        end
+      end
+
+      def insert_newline_before_word
+        m = @output.match(/(?:([^\w \t\n])|(\w)[ \t]+)(\w*)\z/, @line_start)
+        return if m.nil?
+        word = m[3]
+        @output[m.begin(0)..] = "#{m[1]}#{m[2]}\n#{@prefix}#{word}"
+        @line_start = @output.size - word.size
+        @column = @prefix_width + Buffer.display_width(word)
+        @bol = false
+      end
+
+      def insert_newline(prefix)
+        return if @bol
+        @output.sub!(/[ \t]+\z/, "")
+        @output << "\n" << prefix
+        @line_start = @output.size
+        @column = Buffer.display_width(prefix)
+        @bol = true
+      end
+
+      # The newline that ends the text is kept even on an otherwise empty
+      # line, and no prefix follows it.
+      def insert_final_newline
+        @output.sub!(/[ \t]+\z/, "")
+        @output << "\n"
+        @line_start = @output.size
+        @column = 0
+        @bol = true
+      end
+
+      def insert_char(c, w)
+        if @bol && /[ \t]/.match?(c)
+          return
+        end
+        @output << c
+        @column += w
+        @bol = false
+      end
+    end
+
     refine Buffer do
       def fill_region(s = Buffer.current.point, e = Buffer.current.mark)
         s, e = Buffer.region_boundaries(s, e)
         save_excursion do
-          str = substring(s, e)
           goto_char(s)
           pos = point
           beginning_of_line
           column = Buffer.display_width(substring(point, pos))
-          replace(fill_string(str, column), start: s, end: e)
+          prefix_re = fill_prefix_regexp(comment_line?)
+          prefix = fill_prefix(substring(point, e), prefix_re)
+          lines = substring(s, e).lines
+          head = column == 0 && lines[0] ? lines[0][prefix_re] : ""
+          body = lines.each_with_index.map { |line, i|
+            i == 0 ? line[head.size..] : line.sub(prefix_re, "")
+          }.join
+          replace(Filler.new(column, prefix).fill(head, body),
+                  start: s, end: e)
         end
       end
 
       def fill_paragraph
         beginning_of_line
-        while !beginning_of_buffer? &&
-            !looking_at?(/^[ \t]*$/)
+        separator = fill_paragraph_separator(comment_line?)
+        while !beginning_of_buffer? && !looking_at?(separator)
           backward_line
         end
-        while looking_at?(/^[ \t]*$/)
+        while !end_of_buffer? && looking_at?(separator)
           forward_line
         end
         s = point
         begin
           forward_line
-        end while !end_of_buffer? && !looking_at?(/^[ \t]*$/)
+        end while !end_of_buffer? && !looking_at?(separator)
         if beginning_of_line?
           backward_char
         end
@@ -36,69 +155,43 @@ module Textbringer
 
       private
 
-      def fill_string(str, column)
-        input = StringIO.new(str)
-        output = +""
-        fill_column = CONFIG[:fill_column]
-        prev_c = nil
-        while c = input.getc
-          if c == "\n"
-            if column < fill_column && !input.eof?
-              if /(?=[\u{0000}-\u{00FF}])[[:graph:]]/.match?(prev_c)
-                column = insert_space_between_words(input, output, column)
-              end
-              next
-            end
-            column = insert_newline(output)
-          else
-            w = Buffer.display_width(c)
-            if column + w > fill_column || column >= fill_column
-              if /\w/.match?(prev_c) && /\w/.match?(c)
-                column = insert_newline_before_word(output, column)
-              else
-                column = insert_newline(output)
-              end
-            end
-            column = insert_char(output, column, c, w)
-          end
-          prev_c = c
-        end
-        output
+      # Whether the current line is a comment line of the buffer's mode.
+      # Point must be at the beginning of the line.
+      def comment_line?
+        re = mode&.comment_prefix_regexp
+        !re.nil? && looking_at?(re)
       end
 
-      def insert_space_between_words(input, output, column)
-        c = input.getc
-        input.ungetc(c)
-        if /(?=[\u{0000}-\u{00FF}])[[:graph:]]/.match?(c)
-          output << " "
-          column + 1
+      # A line that ends the paragraph: a blank line, or, when filling a
+      # comment, any line that is not a comment with something in it.
+      def fill_paragraph_separator(comment)
+        if comment
+          /^(?!#{mode.comment_prefix_regexp}[^ \t\n])/
         else
-          column
+          /^[ \t]*$/
         end
       end
 
-      def insert_newline_before_word(output, column)
-        if output.sub!(/(?:([^\w \t\n])|(\w)[ \t]+)(\w*)\z/, "\\1\\2\n")
-          output << $3
-          Buffer.display_width($3)
+      # What is stripped from the start of each line before filling and
+      # put back by the prefix: indentation, and the comment leader when
+      # filling a comment.
+      def fill_prefix_regexp(comment)
+        if comment
+          /\A(?:#{mode.comment_prefix_regexp}|[ \t]*)/
         else
-          column
+          /\A[ \t]*/
         end
       end
 
-      def insert_newline(output)
-        output.sub!(/[ \t]\z/, "")
-        output << "\n"
-        0
-      end
-
-      def insert_char(output, column, c, w)
-        if column == 0 && /[ \t]/.match?(c)
-          column
-        else
-          output << c
-          column + w
-        end
+      # The prefix of the second line, or of the first line when there is
+      # no second line, is the prefix of every line after the first, as
+      # with adaptive-fill-mode in Emacs.  The first line keeps its own
+      # prefix.
+      def fill_prefix(str, prefix_re)
+        first, second = str.lines
+        line = second && !second.sub(prefix_re, "").match?(/\A\n?\z/) ?
+          second : first
+        line ? line[prefix_re] : ""
       end
     end
   end