gettext_i18n_rails_js 3.1.0 → 3.1.1

data/vendor/bundle/ruby/4.0.0/gems/railties-8.1.2/lib/rails/source_annotation_extractor.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+begin
+  require "prism"
+rescue LoadError
+  # If Prism isn't available (because of using an older Ruby version) then we'll
+  # define a fallback for the ParserExtractor using ripper.
+  require "ripper"
+end
+
+module Rails
+  # Implements the logic behind +Rails::Command::NotesCommand+. See <tt>rails notes --help</tt> for usage information.
+  #
+  # Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
+  # represent the line where the annotation lives, its tag, and its text. Note
+  # the filename is not stored.
+  #
+  # Annotations are looked for in comments and modulus whitespace they have to
+  # start with the tag optionally followed by a colon. Everything up to the end
+  # of the line (or closing ERB comment tag) is considered to be their text.
+  class SourceAnnotationExtractor
+    # Wraps a regular expression that will be tested against each of the source
+    # file's comments.
+    class ParserExtractor < Struct.new(:pattern)
+      if defined?(Prism)
+        def annotations(file)
+          result = Prism.parse_file(file)
+          return [] unless result.success?
+
+          result.comments.filter_map do |comment|
+            Annotation.new(comment.location.start_line, $1, $2) if comment.location.slice =~ pattern
+          end
+        end
+      else
+        class Parser < Ripper
+          attr_reader :comments, :pattern
+
+          def initialize(source, pattern:)
+            super(source)
+            @pattern = pattern
+            @comments = []
+          end
+
+          def on_comment(value)
+            @comments << Annotation.new(lineno, $1, $2) if value =~ pattern
+          end
+        end
+
+        def annotations(file)
+          contents = File.read(file, encoding: Encoding::BINARY)
+          parser = Parser.new(contents, pattern: pattern).tap(&:parse)
+          parser.error? ? [] : parser.comments
+        end
+      end
+    end
+
+    # Wraps a regular expression that will iterate through a file's lines and
+    # test each one for the given pattern.
+    class PatternExtractor < Struct.new(:pattern)
+      def annotations(file)
+        lineno = 0
+
+        File.readlines(file, encoding: Encoding::BINARY).inject([]) do |list, line|
+          lineno += 1
+          next list unless line =~ pattern
+          list << Annotation.new(lineno, $1, $2)
+        end
+      end
+    end
+
+    class Annotation < Struct.new(:line, :tag, :text)
+      def self.directories
+        @@directories ||= %w(app config db lib test)
+      end
+
+      # Registers additional directories to be included
+      #   Rails::SourceAnnotationExtractor::Annotation.register_directories("spec", "another")
+      def self.register_directories(*dirs)
+        directories.push(*dirs)
+      end
+
+      def self.tags
+        @@tags ||= %w(OPTIMIZE FIXME TODO)
+      end
+
+      # Registers additional tags
+      #   Rails::SourceAnnotationExtractor::Annotation.register_tags("TESTME", "DEPRECATEME")
+      def self.register_tags(*additional_tags)
+        tags.push(*additional_tags)
+      end
+
+      def self.extensions
+        @@extensions ||= {}
+      end
+
+      # Registers new Annotations File Extensions
+      #   Rails::SourceAnnotationExtractor::Annotation.register_extensions("css", "scss", "sass", "less", "js") { |tag| /\/\/\s*(#{tag}):?\s*(.*)$/ }
+      def self.register_extensions(*exts, &block)
+        extensions[/\.(#{exts.join("|")})$/] = block
+      end
+
+      register_extensions("builder", "rb", "rake", "ruby") do |tag|
+        ParserExtractor.new(/#\s*(#{tag}):?\s*(.*)$/)
+      end
+
+      register_extensions("yml", "yaml") do |tag|
+        PatternExtractor.new(/#\s*(#{tag}):?\s*(.*)$/)
+      end
+
+      register_extensions("js") do |tag|
+        PatternExtractor.new(/\/\/\s*(#{tag}):?\s*(.*)$/)
+      end
+
+      register_extensions("css") do |tag|
+        PatternExtractor.new(/\/\*\s*(#{tag}):?\s*(.*?)(?:\*\/)?$/)
+      end
+
+      register_extensions("erb") do |tag|
+        PatternExtractor.new(/<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/)
+      end
+
+      # Returns a representation of the annotation that looks like this:
+      #
+      #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
+      #
+      # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
+      # Otherwise the string contains just line and text.
+      def to_s(options = {})
+        s = +"[#{line.to_s.rjust(options[:indent])}] "
+        s << "[#{tag}] " if options[:tag]
+        s << text
+      end
+    end
+
+    # Prints all annotations with tag +tag+ under the root directories +app+,
+    # +config+, +db+, +lib+, and +test+ (recursively).
+    #
+    # If +tag+ is <tt>nil</tt>, annotations with either default or registered tags are printed.
+    #
+    # Specific directories can be explicitly set using the <tt>:dirs</tt> key in +options+.
+    #
+    #   Rails::SourceAnnotationExtractor.enumerate 'TODO|FIXME', dirs: %w(app lib), tag: true
+    #
+    # If +options+ has a <tt>:tag</tt> flag, it will be passed to each annotation's +to_s+.
+    #
+    # See SourceAnnotationExtractor#find_in for a list of file extensions that will be taken into account.
+    #
+    # This class method is the single entry point for the <tt>rails notes</tt> command.
+    def self.enumerate(tag = nil, options = {})
+      tag ||= Annotation.tags.join("|")
+      extractor = new(tag)
+      dirs = options.delete(:dirs) || Annotation.directories
+      extractor.display(extractor.find(dirs), options)
+    end
+
+    attr_reader :tag
+
+    def initialize(tag)
+      @tag = tag
+    end
+
+    # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
+    # with their annotations.
+    def find(dirs)
+      dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+    end
+
+    # Returns a hash that maps filenames under +dir+ (recursively) to arrays
+    # with their annotations. Files with extensions registered in
+    # <tt>Rails::SourceAnnotationExtractor::Annotation.extensions</tt> are
+    # taken into account. Only files with annotations are included.
+    def find_in(dir)
+      results = {}
+
+      Dir.glob("#{dir}/*") do |item|
+        next if File.basename(item).start_with?(".")
+
+        if File.directory?(item)
+          results.update(find_in(item))
+        else
+          extension = Annotation.extensions.detect do |regexp, _block|
+            regexp.match(item)
+          end
+
+          if extension
+            pattern = extension.last.call(tag)
+
+            # In case a user-defined pattern returns nothing for the given set
+            # of tags, we exit early.
+            next unless pattern
+
+            # If a user-defined pattern returns a regular expression, we will
+            # wrap it in a PatternExtractor to keep the same API.
+            pattern = PatternExtractor.new(pattern) if pattern.is_a?(Regexp)
+
+            annotations = pattern.annotations(item)
+            results.update(item => annotations) if annotations.any?
+          end
+        end
+      end
+
+      results
+    end
+
+    # Prints the mapping from filenames to annotations in +results+ ordered by filename.
+    # The +options+ hash is passed to each annotation's +to_s+.
+    def display(results, options = {})
+      options[:indent] = results.flat_map { |f, a| a.map(&:line) }.max.to_s.size
+      results.keys.sort.each do |file|
+        puts "#{file}:"
+        results[file].each do |note|
+          puts "  * #{note.to_s(options).strip}"
+        end
+        puts
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/railties-8.1.2/lib/rails/test_unit/line_filtering.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rails/test_unit/runner"
+
+module Rails
+  module LineFiltering # :nodoc:
+    def self.extended(obj)
+      require "minitest"
+
+      case Minitest::VERSION
+      when /^5/ then
+        obj.extend MT5
+      when /^6/ then
+        obj.extend MT6
+      end
+    end
+
+    module MT5
+      def run(reporter, options = {})
+        options = options.merge(filter: Rails::TestUnit::Runner.compose_filter(self, options[:filter]))
+
+        super
+      end
+    end
+
+    module MT6
+      def run_suite(reporter, options = {})
+        options = options.merge(include: Rails::TestUnit::Runner.compose_filter(self, options[:include]))
+
+        super
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/railties-8.1.2/lib/rails/test_unit/reporter.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "minitest"
+
+module Rails
+  class TestUnitReporter < Minitest::StatisticsReporter
+    @app_root = ENV["RAILS_TEST_PWD"]
+    singleton_class.attr_accessor :app_root
+
+    @executable = ENV.fetch("RAILS_TEST_EXECUTABLE", "bin/rails test")
+    singleton_class.attr_accessor :executable
+
+    def prerecord(test_class, test_name)
+      super
+      if options[:verbose]
+        io.print "%s#%s = " % [test_class.name, test_name]
+      end
+    end
+
+    def record(result)
+      super
+
+      if options[:verbose]
+        io.puts color_output(format_line(result), by: result)
+      else
+        io.print color_output(result.result_code, by: result)
+      end
+
+      if output_inline? && result.failure && (!result.skipped? || options[:verbose])
+        io.puts
+        io.puts
+        io.puts color_output(result, by: result)
+        io.puts
+        io.puts format_rerun_snippet(result)
+        io.puts
+      end
+
+      if fail_fast? && result.failure && !result.skipped?
+        raise Interrupt
+      end
+    end
+
+    def report
+      return if output_inline? || filtered_results.empty?
+      io.puts
+      io.puts "Failed tests:"
+      io.puts
+      io.puts aggregated_results
+    end
+
+    def aggregated_results # :nodoc:
+      filtered_results.map { |result| format_rerun_snippet(result) }.join "\n"
+    end
+
+    def filtered_results
+      if options[:verbose]
+        results
+      else
+        results.reject(&:skipped?)
+      end
+    end
+
+    def relative_path_for(file)
+      if app_root
+        File.expand_path(file).sub(/^#{app_root}\/?/, "")
+      else
+        file
+      end
+    end
+
+    private
+      def output_inline?
+        options[:output_inline]
+      end
+
+      def fail_fast?
+        options[:fail_fast]
+      end
+
+      def format_line(result)
+        "%.2f s = %s" % [result.time, result.result_code]
+      end
+
+      def format_rerun_snippet(result)
+        location, line = if result.respond_to?(:source_location)
+          result.source_location
+        else
+          result.method(result.name).source_location
+        end
+
+        "#{self.class.executable} #{relative_path_for(location)}:#{line}"
+      end
+
+      def app_root
+        @app_root ||= self.class.app_root ||
+          if ENV["RAILS_TEST_PWD"]
+            ENV["RAILS_TEST_PWD"]
+          elsif defined?(ENGINE_ROOT)
+            ENGINE_ROOT
+          elsif Rails.respond_to?(:root)
+            Rails.root
+          else
+            Dir.pwd
+          end
+      end
+
+      def colored_output?
+        options[:color] && io.respond_to?(:tty?) && io.tty?
+      end
+
+      codes = { red: 31, green: 32, yellow: 33 }
+      COLOR_BY_RESULT_CODE = {
+        "." => codes[:green],
+        "E" => codes[:red],
+        "F" => codes[:red],
+        "S" => codes[:yellow]
+      }
+
+      def color_output(string, by:)
+        if colored_output?
+          "\e[#{COLOR_BY_RESULT_CODE[by.result_code]}m#{string}\e[0m"
+        else
+          string
+        end
+      end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/rdoc-7.1.0/README.md

@@ -0,0 +1,195 @@
+# RDoc - Ruby Documentation System
+
+- GitHub: [https://github.com/ruby/rdoc](https://github.com/ruby/rdoc)
+- Issues: [https://github.com/ruby/rdoc/issues](https://github.com/ruby/rdoc/issues)
+
+## Description
+
+RDoc produces HTML and command-line documentation for Ruby projects.  RDoc includes the `rdoc` and `ri` tools for generating and displaying documentation from the command-line.
+
+## Generating Documentation
+
+Once installed, you can create documentation using the `rdoc` command
+
+```shell
+rdoc [options] [names...]
+```
+
+For an up-to-date option summary, type
+
+```shell
+rdoc --help
+```
+
+A typical use might be to generate documentation for a package of Ruby source (such as RDoc itself).
+
+```shell
+rdoc
+```
+
+This command generates documentation for all the Ruby and C source files in and below the current directory.  These will be stored in a documentation tree starting in the subdirectory `doc`.
+
+You can make this slightly more useful for your readers by having the index page contain the documentation for the primary file.  In our case, we could type
+
+```shell
+rdoc --main README.md
+```
+
+You'll find information on the various formatting tricks you can use in comment blocks in the documentation this generates.
+
+RDoc uses file extensions to determine how to process each file.  File names ending `.rb` and `.rbw` are assumed to be Ruby source.  Files ending `.c` are parsed as C files.  All other files are assumed to contain just Markup-style markup (with or without leading `#` comment markers).  If directory names are passed to RDoc, they are scanned recursively for C and Ruby source files only.
+
+To generate documentation using `rake` see [RDoc::Task](https://ruby.github.io/rdoc/RDoc/Task.html).
+
+To generate documentation programmatically:
+
+```rb
+require 'rdoc/rdoc'
+
+options = RDoc::Options.new
+options.files = ['a.rb', 'b.rb']
+options.setup_generator 'aliki'
+# see RDoc::Options
+
+rdoc = RDoc::RDoc.new
+rdoc.document options
+# see RDoc::RDoc
+```
+
+You can specify the target files for document generation with `.document` file in the project root directory. `.document` file contains a list of file and directory names including comment lines starting with `#`. See [https://github.com/ruby/rdoc/blob/master/.document](https://github.com/ruby/rdoc/blob/master/.document) as an example.
+
+## Writing Documentation
+
+To write documentation for RDoc, place a comment above the class, module, method, constant, or attribute you want documented:
+
+```rb
+##
+# This class represents an arbitrary shape by a series of points.
+class Shape
+  ##
+  # Creates a new shape described by a +polyline+.
+  #
+  # If the +polyline+ does not end at the same point it started at the
+  # first pointed is copied and placed at the end of the line.
+  #
+  # An ArgumentError is raised if the line crosses itself, but shapes may
+  # be concave.
+  def initialize polyline
+    # ...
+  end
+end
+```
+
+### Markup Formats
+
+RDoc supports multiple markup formats:
+
+| Format | File Extensions | Default For |
+|--------|-----------------|-------------|
+| [RDoc](doc/markup_reference/rdoc.rdoc) | `.rdoc` | `.rb`, `.c` files |
+| [Markdown](doc/markup_reference/markdown.md) | `.md` | None |
+| RD | `.rd` | None |
+| TomDoc | N/A | None |
+
+**RDoc markup** is currently the default format for Ruby and C files. However, we plan to retire it in favor of Markdown in the future.
+
+**Markdown** support is actively being improved. Once it reaches feature parity with RDoc markup, it will become the default format.
+
+For standalone documentation files, we recommend writing `.md` files instead of `.rdoc` files.
+
+**RD** and **TomDoc** are legacy formats. We highly discourage their use in new projects.
+
+### Specifying Markup Format
+
+**Per-file:** Add a `:markup:` directive at the top of a Ruby file:
+
+```ruby
+# :markup: markdown
+
+# This class uses **Markdown** for documentation.
+class MyClass
+end
+```
+
+**Per-project:** Create a `.rdoc_options` file in your project root:
+
+```yaml
+markup: markdown
+```
+
+**Command line:**
+
+```bash
+rdoc --markup markdown
+```
+
+### Feature Differences
+
+| Feature | RDoc Markup | Markdown |
+|---------|-------------|----------|
+| Headings | `= Heading` | `# Heading` |
+| Bold | `*word*` | `**word**` |
+| Italic | `_word_` | `*word*` |
+| Monospace | `+word+` | `` `word` `` |
+| Links | `{text}[url]` | `[text](url)` |
+| Code blocks | Indent 2 spaces | Fenced with ``` |
+| Cross-references | Automatic | Automatic |
+| Directives (`:nodoc:`, etc.) | Supported | Supported |
+| Tables | Not supported | Supported |
+| Strikethrough | `<del>text</del>` | `~~text~~` |
+| Footnotes | Not supported | Supported |
+
+For complete syntax documentation, see:
+
+- [RDoc Markup Reference](doc/markup_reference/rdoc.rdoc)
+- [Markdown Reference](doc/markup_reference/markdown.md)
+
+### Directives
+
+Comments can contain directives that tell RDoc information that it cannot otherwise discover through parsing. See RDoc::Markup@Directives to control what is or is not documented, to define method arguments or to break up methods in a class by topic. See RDoc::Parser::Ruby for directives used to teach RDoc about metaprogrammed methods.
+
+See RDoc::Parser::C for documenting C extensions with RDoc.
+
+### Documentation Coverage
+
+To determine how well your project is documented run `rdoc -C lib` to get a documentation coverage report. `rdoc -C1 lib` includes parameter names in the documentation coverage report.
+
+## Theme Options
+
+RDoc ships with two built-in themes:
+
+- **Aliki** (default) - A modern, clean theme with improved navigation and search
+- **Darkfish** (deprecated) - The classic theme, will be removed in v8.0
+
+To use the Darkfish theme instead of the default Aliki theme:
+
+```shell
+rdoc --format darkfish
+```
+
+Or in your `.rdoc_options` file:
+
+```yaml
+generator_name: darkfish
+```
+
+There are also a few community-maintained themes for RDoc:
+
+- [rorvswild-theme-rdoc](https://github.com/BaseSecrete/rorvswild-theme-rdoc)
+- [hanna](https://github.com/jeremyevans/hanna) (a fork maintained by [Jeremy Evans](https://github.com/jeremyevans))
+
+Please follow the theme's README for usage instructions.
+
+## Bugs
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for information on filing a bug report.  It's OK to file a bug report for anything you're having a problem with.  If you can't figure out how to make RDoc produce the output you like that is probably a documentation bug.
+
+## License
+
+RDoc is Copyright (c) 2001-2003 Dave Thomas, The Pragmatic Programmers. Portions (c) 2007-2011 Eric Hodel.  Portions copyright others, see individual files and LEGAL.rdoc for details.
+
+RDoc is free software, and may be redistributed under the terms specified in LICENSE.rdoc.
+
+## Warranty
+
+This software is provided "as is" and without any express or implied warranties, including, without limitation, the implied warranties of merchantability and fitness for a particular purpose.