include2ignore 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1980856274a5f39c2eaf284ba7c0f42263261a873a1fca9d7257243b47585852
+  data.tar.gz: b3891c0ab2157af33f311c0869694e9d296bf60b5642cc8a1ea3f2bd3a17c002
+SHA512:
+  metadata.gz: ba2816257df56abb506128ccba3bff9a901db0b5062e014e24836402b6db4a687a2fe00c3ab7ab41e856e354fb077d1ea603f6121bcdf6abb5d9116f26a4e425
+  data.tar.gz: e0f4a554fd8729f0c9c9fbbbf18b9c48d867c36e8024b5bd0ed88c1c4a76db3868f71f92975ca868d9dad41301481b7de60d60709769919d15740a1a4fa8a557

data/LICENSE.txt

@@ -0,0 +1,17 @@
+Copyright (c) 2026 Ismo Kärkkäinen
+
+The Universal Permissive License (UPL), Version 1.0
+
+Subject to the condition set forth below, permission is hereby granted to any person obtaining a copy of this software, associated documentation and/or data (collectively the "Software"), free of charge and under any and all copyright rights in the Software, and any and all patent rights owned or freely licensable by each licensor hereunder covering either (i) the unmodified Software as contributed to or provided by such licensor, or (ii) the Larger Works (as defined below), to deal in both
+
+(a) the Software, and
+
+(b) any piece of software and/or hardware listed in the lrgrwrks.txt file if one is included with the Software (each a “Larger Work” to which the Software is contributed by such licensors),
+
+without restriction, including without limitation the rights to copy, create derivative works of, display, perform, and distribute the Software and make, use, sell, offer for sale, import, export, have made, and have sold the Software and the Larger Work(s), and to sublicense the foregoing rights on either these or other terms.
+
+This license is subject to the following condition:
+
+The above copyright notice and either this complete permission notice or at a minimum a reference to the UPL must be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/include2ignore

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require_relative '../lib/include2ignore'
+require 'optparse'
+
+
+def read(filename)
+  rules = Include2Ignore::Include::Classifier.new
+  f = filename.nil? ? $stdin : File.new(filename, 'rt')
+  idx = 0
+  f.each_line(chomp: true) do |line|
+    idx += 1
+    Include2Ignore::Warnings.where("#{idx}: #{line}")
+    rules.add(line)
+  end
+  f.close unless filename.nil?
+  rules.close
+  rules
+end
+
+def main
+  input_name = nil
+  output_name = nil
+  output_format = nil
+  directory = Dir.pwd
+  skip_name = nil
+  dump_format = nil
+  verbose = false
+
+  parser = OptionParser.new do |opts|
+    opts.summary_indent = '  '
+    opts.summary_width = 24
+    opts.banner = 'Usage: include2ignore [options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-i', '--input FILE', 'Read from include FILE, not stdin.') do |f|
+      input_name = f
+    end
+    opts.on('-o', '--output FILE', 'Write to ignore FILE, not stdout.') do |f|
+      output_name = f
+    end
+    opts.on('-f', '--format FORMAT', 'Output format: file name or internal format name.') do |fmt|
+      output_format = fmt
+    end
+    opts.on('-d', '--directory DIR', 'Use base DIR, not current directory.') do |d|
+      directory = d
+    end
+    opts.on('--dir-link ACTION', "Symlink handling: #{Include2Ignore::Search::DIR_SYMLINK_HANDLING.map { |h| h == Include2Ignore::Search.dir_symlink_handling ? "*#{h}*" : h }.join(', ')}") do |action|
+      a = action.downcase.to_sym
+      unless Include2Ignore::Search::DIR_SYMLINK_HANDLING.include?(a)
+        $stderr.puts("Allowed --dir-symlink values: #{Include2Ignore::Search::DIR_SYMLINK_HANDLING.join(', ')}, got: #{action}")
+        return 1
+      end
+      Include2Ignore::Search.dir_symlink_handling = a
+    end
+    opts.on('--file-link ACTION', "Symlink handling: #{Include2Ignore::Search::FILE_SYMLINK_HANDLING.map { |h| h == Include2Ignore::Search.file_symlink_handling ? "*#{h}*" : h }.join(', ')}") do |action|
+      a = action.downcase.to_sym
+      unless Include2Ignore::Search::FILE_SYMLINK_HANDLING.include?(a)
+        $stderr.puts("Allowed --file-symlink values: #{Include2Ignore::Search::FILE_SYMLINK_HANDLING.join(', ')}, got: #{action}")
+        return 1
+      end
+      Include2Ignore::Search.file_symlink_handling = a
+    end
+    opts.on('--skip FILE', 'Read skip rules from FILE.') do |f|
+      skip_name = f
+    end
+    opts.on('--verbose', 'Verbose output, shows pattern interpretations.') do
+      verbose = true
+    end
+    opts.on('--dump FORMAT', 'Dump internal FORMAT to output and exit.') do |fmt|
+      dump_format = fmt
+    end
+    opts.on('-h', '--help', 'Print this help and exit.') do
+      $stdout.puts %(#{opts}
+Reads include file, finds files under directory, and outputs ignore file.
+
+#{Include2Ignore::Include.doc}
+#{Include2Ignore::Search.doc}
+#{Include2Ignore::IgnoreConfiguration.doc}
+Directory with nothing under it included or explicitly excluded is ignored to
+avoid listing all files under it.
+
+Skip rules can be used to prevent searching of directories or to skip files
+like ACTION "skip" does for symlinks.
+)
+      return 0
+    end
+  end
+  parser.order!
+
+  # Dump internal output.
+  unless dump_format.nil?
+    return 0 unless Include2Ignore::IgnoreConfiguration.write(output_name, dump_format).nil?
+    $stderr.puts("Not an internal format name: #{dump_format}")
+    return 1
+  end
+
+  # Output format.
+  format = Include2Ignore::IgnoreConfiguration.read(output_format)
+  if format.nil?
+    $stderr.puts("Not a file nor format name: #{output_format}")
+    return 1
+  end
+  begin
+    format = Include2Ignore::IgnoreConfiguration::ConfigurationAlternatives.new(format)
+  rescue ArgumentError => e
+    $stderr.puts("Configuration is not valid: #{e}")
+    return 1
+  end
+
+  # Directory.
+  unless File.directory?(directory)
+    $stderr.puts("Not a directory: #{directory}")
+    return 1
+  end
+  directory = File.realdirpath(directory)
+
+  Include2Ignore::Warnings.output_explanations(verbose)
+
+  # Input file.
+  begin
+    rules = read(input_name)
+  rescue Exception => e
+    $stderr.puts(%(Failed to read input:#{input_name.nil? ? ' ' : " #{input_name}: "}#{e}))
+    return 2
+  end
+
+  # Skip rules or empty default.
+  if skip_name.nil?
+    skip = Include2Ignore::Include::Classifier.new
+    skip.close
+  else
+    begin
+      skip = read(skip_name)
+    rescue Exception => e
+      $stderr.puts("Failed to read input: #{skip_name}: #{e}")
+      return 2
+    end
+  end
+
+  # Search.
+  results = Include2Ignore::Classified.new
+  begin
+    Include2Ignore::Search.traverse(directory, skip) do |path_parts, is_dir, invalid|
+      kind = is_dir ? Include2Ignore::Include::DIR : Include2Ignore::Include::FILE
+      exclude = invalid ? true : rules.exclude(path_parts, kind)
+      results.add(path_parts, exclude, is_dir)
+    end
+  rescue Errno::EACCES, Errno::ENOENT => e
+    $stderr.puts("Error traversing directory: #{e}")
+    return 4
+  end
+
+  # Shorten and save results.
+  results.pick
+  included, _undecided, excluded = results.counts
+  begin
+    out = Include2Ignore::Ignore.new(output_name, format.select(included, excluded))
+  rescue Exception => e
+    $stderr.puts("Error opening output file: #{e}")
+    return 3
+  end
+  results.output(out)
+  out.close
+  0
+end
+
+exit(main) if File.basename(__FILE__) == File.basename($PROGRAM_NAME)

data/lib/include2ignore/config.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require 'yaml'
+
+
+module Include2Ignore
+  # Configuration file handling.
+  module IgnoreConfiguration
+    # Built-in configs to be dumped outside.
+    ALL = <<EOF
+include_majority:
+  include: '#' # Include lines as comments.
+  ignore: '' # Ignore lines have no prefix.
+EOF
+
+    DEFAULT = <<EOF
+include_majority:
+  include: false # Include lines omitted.
+  ignore: '' # Ignore lines have no prefix.
+EOF
+
+    DOCKER = <<EOF
+include_majority: # More included files than ignored.
+  include: false # Include lines omitted.
+  ignore: '' # Ignore lines have no prefix.
+ignore_majority: # More ignored files, flip for smaller file.
+  header: '*' # Start with ignore everything.
+  include: '!' # Includes are exceptions to ignore all.
+  ignore: false # Header covers everything.
+EOF
+
+    DEFAULT_FORMAT = :default
+    BUILTINS = {
+      all: ALL,
+      default: DEFAULT,
+      docker: DOCKER
+    }.freeze
+
+    def self.doc
+      <<EOF
+If FORMAT is a file name it is read. Otherwise internal format is used.
+Internal formats: #{BUILTINS.keys.sort!.join(', ')}. Defaults to "#{DEFAULT_FORMAT}".
+
+If format allows, ignore file may ignore everything and add exceptions if that
+produces a file with fewer entries. Dump internal format "docker" for info.
+EOF
+    end
+
+    def self.get(name)
+      BUILTINS[name.downcase.to_sym]
+    end
+
+    # Reads from file, or from built-ins, or provides default if name is nil.
+    def self.read(name)
+      return YAML.safe_load(BUILTINS[DEFAULT_FORMAT]) if name.nil?
+      begin
+        YAML.safe_load_file(name)
+      rescue StandardError
+        YAML.safe_load(get(name))
+      end
+    end
+
+    def self.write(nil_filename_or_has_puts_string, format)
+      fmt = get(format)
+      unless fmt.nil?
+        if nil_filename_or_has_puts_string.nil?
+          output = $stdout
+        elsif nil_filename_or_has_puts_string.is_a?(String)
+          output = File.new(nil_filename_or_has_puts_string, 'wt')
+        elsif nil_filename_or_has_puts_string.respond_to?(:puts)
+          output = nil_filename_or_has_puts_string
+        else
+          raise ArgumentError, 'Include2Ignore::IgnoreConfiguration::write: Not nil, string, nor puts in argument'
+        end
+        output.puts(fmt)
+      end
+      fmt
+    end
+
+    # Contains per-line configuration.
+    class Configuration
+      attr_reader :keep, :drop, :header
+
+      def initialize(config)
+        @keep = config.fetch('include', false)
+        @drop = config.fetch('ignore', false)
+        @header = config['header']
+      end
+    end
+
+    # Handles configuration file contents and selection of applicable config.
+    class ConfigurationAlternatives
+      attr_reader :include_majority, :ignore_majority
+
+      def initialize(config)
+        raise ArgumentError, 'Not a hash' unless config.is_a?(Hash)
+        @include_majority = config.key?('include_majority') ? Configuration.new(config['include_majority']) : nil
+        @ignore_majority = config.key?('ignore_majority') ? Configuration.new(config['ignore_majority']) : nil
+        raise ArgumentError, 'No majority configurations.' if @include_majority.nil? && @ignore_majority.nil?
+      end
+
+      def select(include_count, ignore_count)
+        return @include_majority if @ignore_majority.nil?
+        return @ignore_majority if @include_majority.nil?
+        include_count < ignore_count ? @ignore_majority : @include_majority
+      end
+    end
+  end
+end

data/lib/include2ignore/ignore.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+module Include2Ignore
+  # Writes to ignore file, output object, or standard output.
+  class Ignore
+    attr_reader :output, :puts_include, :puts_exclude
+
+    def initialize(nil_filename_or_has_puts_string, config)
+      if nil_filename_or_has_puts_string.nil?
+        @output = $stdout
+      elsif nil_filename_or_has_puts_string.is_a?(String)
+        @output = File.new(nil_filename_or_has_puts_string, 'wt')
+      elsif nil_filename_or_has_puts_string.respond_to?(:puts)
+        @output = nil_filename_or_has_puts_string
+      else
+        raise ArgumentError, 'Include2Ignore::Ignore::initialize: Not nil, string, nor puts in argument'
+      end
+      @output.puts(config.header) if config.header
+      @puts_include = func(config.keep)
+      @puts_exclude = func(config.drop)
+    end
+
+    def add_include(line)
+      @puts_include.call(line)
+    end
+
+    def add_exclude(line)
+      @puts_exclude.call(line)
+    end
+
+    def close
+      @output.close if @output.respond_to?(:close)
+    end
+
+    private
+
+    def func(prefix)
+      return ->(line) {} unless prefix.is_a?(String)
+      return ->(line) { @output.puts(line) } if prefix.empty?
+      ->(line) { @output.puts("#{prefix}#{line}") }
+    end
+  end
+
+  # Helper for Classified.
+  class Level
+    attr_reader :level, :children, :kind, :name, :included, :undecided, :excluded
+
+    def initialize(level, path_parts, is_directory)
+      @level = level
+      @children = {}
+      @kind = nil
+      @name = Level.decided_name(path_parts[0..level], (path_parts.size == level + 1) ? is_directory : true)
+      @included = 0
+      @undecided = 0
+      @excluded = 0
+    end
+
+    def add(path_parts, exclude, is_directory)
+      if path_parts.size == @level + 1
+        @kind = exclude
+        return
+      end
+      child = @children[path_parts[@level + 1]]
+      if child.nil?
+        child = Level.new(@level + 1, path_parts, is_directory)
+        @children[path_parts[@level + 1]] = child
+      end
+      child.add(path_parts, exclude, is_directory)
+    end
+
+    def self.decided_name(path_parts, is_directory)
+      parts = [ '' ].concat(path_parts)
+      parts.push('') if is_directory
+      File.join(parts)
+    end
+
+    def counts
+      @included = 0
+      @undecided = 0
+      @excluded = 0
+
+      case @kind
+      when true then @excluded = 1
+      when false then @included = 1
+      else
+        @undecided = 1 if @children.empty?
+      end
+      @children.each_value do |child|
+        inc, und, ex = child.counts
+        @included += inc
+        @undecided += und
+        @excluded += ex
+      end
+      [ @included, @undecided, @excluded ]
+    end
+
+    def exclude_undecided
+      return unless @kind.nil?
+      counts if @included.zero? && @undecided.zero? && @excluded.zero?
+      if @undecided.positive? && @included.zero?
+        # Anything explicitly excluded under this is covered.
+        @kind = true
+        @children.clear
+      else
+        @children.each_value(&:exclude_undecided)
+      end
+    end
+
+    def output(saver)
+      unless @kind.nil?
+        @kind ? saver.add_exclude(@name) : saver.add_include(@name)
+      end
+      @children.keys.sort!.each do |key|
+        @children[key].output(saver)
+      end
+    end
+  end
+
+  # Stores decisions for all encountered files.
+  class Classified
+    attr_reader :root
+
+    def initialize
+      @root = {}
+    end
+
+    def add(path_parts, exclude, is_directory)
+      return if path_parts.empty?
+      first = path_parts.first
+      child = @root[first]
+      if child.nil?
+        child = Level.new(0, path_parts, is_directory)
+        @root[first] = child
+      end
+      child.add(path_parts, exclude, is_directory)
+    end
+
+    def counts
+      included = 0
+      undecided = 0
+      excluded = 0
+      @root.each_value do |child|
+        inc, und, ex = child.counts
+        included += inc
+        undecided += und
+        excluded += ex
+      end
+      [ included, undecided, excluded ]
+    end
+
+    def pick
+      @root.each_value(&:exclude_undecided)
+    end
+
+    def output(saver)
+      @root.keys.sort!.each do |key|
+        @root[key].output(saver)
+      end
+    end
+  end
+end

data/lib/include2ignore/include.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+module Include2Ignore
+  # Code related to reading and processing the include file, and comparing with file names.
+  module Include
+    RULES = [
+      [ '\\', :any, :skip, '\\ escapes the meaning of the next character, except newline.' ].freeze,
+      [ '\\', :first, :include ].freeze,
+      [ '#', :first, :comment, '# starting a line makes the line a comment.' ].freeze,
+      [ '!', :first, :exclude, '! starting a line makes the line an exclusion pattern' ].freeze,
+      [ '*', :any, :any, '* matches any full or partial file or directory name.' ].freeze,
+      [ '**', :any, nil, '** separated using "/" matches one or more directory names.' ].freeze,
+      [ '/', :any, :end ].freeze
+    ].freeze
+
+    FIRSTS = RULES.select { |r| r[1] == :first }.to_h { |r| [ r.first, r[2] ] }.freeze
+    ANYS = RULES.select { |r| r[1] == :any && !r[2].nil? }.to_h { |r| [ r.first, r[2] ] }.freeze
+
+    FILE = :file
+    DIR = :dir
+
+    ANY_ONE = Regexp.new('^.*$')
+
+    def self.doc
+      <<EOF
+Include file is one pattern per line. Special characters:
+#{RULES.select { |r| r.last.is_a?(String) }.map { |r| "- #{r.last}\n" }.join}
+Last matching rule decides whether file is included or ignored.
+EOF
+    end
+
+    # Holds all rules and checks if path is to be excluded.
+    class Classifier
+      attr_reader :rules
+
+      def initialize
+        @rules = []
+      end
+
+      # Add only relevant rule types. Discards comments and empty rules.
+      def add(line)
+        r = Rule.new(line)
+        @rules.concat(r.anchored) if %i[include exclude].include?(r.kind)
+      end
+
+      # Prepares the rules for exclude method.
+      def close
+        return if @rules.frozen?
+        @rules.reverse!
+        @rules.freeze
+      end
+
+      # Check rule matching against given array of strings, and FILE/DIR category of last element.
+      def exclude(path_parts, category)
+        @rules.each do |r|
+          return r.exclude if r.match?(path_parts, category)
+        end
+        nil # Caller needs to decide.
+      end
+    end
+
+    # Helper class for one part of the filename. Used during rule reading.
+    class Element
+      FILEDIR = :filedir
+
+      attr_reader :items, :re, :raw
+      attr_accessor :category
+
+      def initialize
+        @items = []
+        @category = FILEDIR
+        @raw = []
+      end
+
+      def push(char)
+        raise StandardError, "Include2Ignore::Include::Element::push called after close: #{char}" if @items.nil?
+        @raw.push(char)
+        item = char
+        if @items.last == :skip
+          @items.pop
+        elsif ANYS.key?(item)
+          item = ANYS[item]
+        end
+        if item == :end
+          # Explicit end flags this as directory name.
+          @category = DIR unless @items.empty?
+          close
+        else
+          @items.push(item)
+        end
+        item
+      end
+
+      # Sets category and performs checks and rule optimizations.
+      def close
+        return if @items.nil?
+        # We never get comments here since Rule detects them and skips the line.
+        if @items.last == :skip # Backslash was last character. No multi-line patterns.
+          Include2Ignore::Warnings.warn('Ends with \\')
+          @items.pop
+        end
+        if @items.empty?
+          @re = :empty
+          Include2Ignore::Warnings.explain("#{@raw.join} = Root or empty.")
+        elsif @items.size == 1 && @items.first == :any
+          @re = ANY_ONE
+          Include2Ignore::Warnings.explain("#{@raw.join} = One directory or file.")
+        elsif @items.size == 2 && @items.first == :any && @items.last == :any
+          # ** with nothing else.
+          @re = :anydirs
+          Include2Ignore::Warnings.explain("#{@raw.join} = One or more directories.")
+        else
+          previous = nil
+          dropped = false
+          @items.delete_if do |item|
+            drop = previous == :any && item == :any
+            previous = item
+            dropped = true if drop
+            drop
+          end
+          Include2Ignore::Warnings.warn('Had consecutive "*" but was not only "**".') if dropped
+          Include2Ignore::Warnings.explain('Starts with whitespace.') if @items.first.is_a?(String) && @items.first.lstrip != @items.first
+          Include2Ignore::Warnings.explain('Ends with whitespace.') if @items.last.is_a?(String) && @items.last.rstrip != @items.last
+          fixeds = []
+          @items.each do |item|
+            if item == :any
+              fixeds.push(item)
+            else
+              fixeds.push([]) if fixeds.empty? || !fixeds.last.is_a?(Array)
+              fixeds.last.push(item)
+            end
+          end
+          parts = fixeds.map do |chars|
+            if chars.is_a?(Array)
+              Regexp.escape(chars.join)
+            else
+              '.*'
+            end
+          end
+          expr = "^#{parts.join}$"
+          @re = Regexp.new(expr)
+          Include2Ignore::Warnings.explain("#{@raw.join} = Regular expression: #{expr}")
+        end
+        @items = nil
+      end
+    end
+
+    # Class for rule used to include or exclude as needed. Used during rule reading.
+    class Rule
+      attr_reader :kind, :elements
+
+      def initialize(line)
+        @kind = :include
+        @elements = []
+        if line.empty?
+          @kind = :comment
+        elsif FIRSTS.key?(line[0])
+          @kind = FIRSTS[line[0]]
+          line = line[1..]
+        end
+        return if @kind == :comment
+        line.each_char do |char|
+          @elements.push(Element.new) if @elements.empty? || @elements.last.items.nil?
+          @elements.last.push(char)
+        end
+        @elements.last.close
+        # Closed element at root without anything becomes anchor to root.
+        # Only last element can be file so ensure categories are DIRs, but keep last.
+        if @elements.size > 1
+          last = @elements.last.category
+          @elements.each { |e| e.category = DIR }
+          @elements.last.category = last
+        end
+        @first_anydirs = @elements.index { |e| e.re == :anydirs } || @elements.size
+        @elements.freeze
+      end
+
+      # Turns elements to arrays of processed elements and FILEDIR is turned
+      # to duplicate arrys with last elemnt category different.
+      def processed_elements
+        out = []
+        if @elements.last.category == Element::FILEDIR
+          # Split to two rules so that later processing can deal with FILE or DIR.
+          out.push(@elements.map { |e| ProcessedElement.new(e.re, e.category == Element::FILEDIR ? FILE : DIR) })
+          out.push(@elements.map { |e| ProcessedElement.new(e.re, DIR) })
+        else
+          out.push(@elements.map { |e| ProcessedElement.new(e.re, e.category) })
+        end
+        out
+      end
+
+      # Returns andchored rules, multiple when needed, with processed elements.
+      def anchored
+        procd = processed_elements
+        if @elements.first.re == :empty
+          # No need for the first empty element due to starting "/" since everything anchored from now on.
+          procd.map { |p| AnchoredRule.new(p[1..], @kind == :exclude) }
+        else
+          # Rule "foo" is like "/foo" and "/**/foo" in shorter notation.
+          [].concat(
+            procd.map { |p| AnchoredRule.new(p, @kind == :exclude) },
+            procd.map { |p| AnchoredRule.new([ ProcessedElement.new(:anydirs, DIR) ].concat(p), @kind == :exclude) }
+          )
+        end
+      end
+    end
+
+    # Contains fixed data for matching.
+    class ProcessedElement
+      attr_reader :category
+      attr_accessor :re
+
+      def initialize(regexp_or_type, category)
+        raise ArgumentError, "Include2Ignore::Include::ProcessedElement::initialize category not allowed: #{category}" unless [DIR, FILE].include?(category)
+        raise ArgumentError, "Include2Ignore::Include::ProcessedElement::initialize mismatch: #{regexp_or_type} and #{category}" if regexp_or_type == :anydirs && category != DIR
+        @re = regexp_or_type
+        @category = category
+      end
+
+      def to_s
+        "#{@re}:#{@category}"
+      end
+
+      def match?(str, category)
+        case category
+        when FILE
+          return false unless @category == FILE
+        when DIR
+          return false unless @category == DIR
+          return true if @re == :anydirs
+        else
+          raise ArgumentError, 'Include2Ignore::Include::ProcessedElement::match? category not FILE or DIR'
+        end
+        return true if str.empty? && @re == :empty
+        @re.match?(str)
+      end
+    end
+
+    # Rule that contains full path from the base directory. Used in actual matching.
+    class AnchoredRule
+      attr_reader :elements, :first_anydirs, :exclude
+
+      def initialize(processed_elements, exclude)
+        @elements = optimize(processed_elements)
+        @first_anydirs = @elements.index { |e| e.re == :anydirs } || @elements.size
+        @exclude = exclude
+      end
+
+      def optimize(elements)
+        opt = []
+        elements.each do |element|
+          next if element.re == :empty
+          unless opt.empty? || element.category != DIR
+            prev = opt.last
+            if prev.re == :anydirs
+              if element.re == :anydirs
+                # .../**/** is same as .../*/**
+                prev.re = ANY_ONE
+              elsif element.re.object_id.equal?(ANY_ONE.object_id) # Only symbol was tested.
+                # For directories, .../**/*/... equals .../*/**/... pattern.
+                opt[-1] = element
+                element = prev
+              end
+            end
+          end
+          opt.push(element)
+        end
+        opt
+      end
+
+      def to_s
+        "#{@exclude ? ' ' : '!'}#{@elements.join(' :: ')}"
+      end
+
+      def matching_element_indexes(part, category, skip_non_anydirs)
+        indexes = []
+        ([ skip_non_anydirs, @first_anydirs ].min...@elements.size).each do |idx|
+          element = @elements[idx]
+          indexes.push(idx) if element.match?(part, category)
+        end
+        indexes
+      end
+
+      def search(index_arrays, array_index, position_index)
+        if array_index == index_arrays.size
+          # Last key is known to match last item, so if that were tested, it would pass.
+          return position_index == @elements.size - 1
+        end
+        if @elements[position_index].re == :anydirs
+          # :anydir absorbs current key and moves to next position.
+          return true if search(index_arrays, array_index + 1, position_index + 1)
+          # :anydir absorbs current key and stays for more.
+          search(index_arrays, array_index + 1, position_index)
+        else
+          # Only current item to match with.
+          return false if index_arrays[array_index].index(position_index).nil?
+          search(index_arrays, array_index + 1, position_index + 1)
+        end
+      end
+
+      def match?(path_parts, category)
+        # Anchored to base directory.
+        slack = path_parts.size - @elements.size
+        return false if slack.negative? # Path too short.
+        return false if slack.positive? && @first_anydirs == @elements.size # Path too long.
+        # Last key must match last item.
+        return false unless @elements.last.match?(path_parts.last, category)
+        # First key must match first item.
+        return false unless @elements.first.match?(path_parts.first, path_parts.size == 1 ? category : DIR)
+        return true if path_parts.size <= 2 # Tested all already.
+        # Form arrays of possible match indexes for search. Omit first and last.
+        index_arrays = []
+        (1...(path_parts.size - 1)).each do |idx|
+          part = path_parts[idx]
+          idxs = matching_element_indexes(part, DIR, idx)
+          return false if idxs.empty?
+          index_arrays.push(idxs)
+        end
+        search(index_arrays, 0, @elements.first.re == :anydirs ? 0 : 1)
+      end
+    end
+  end
+end

data/lib/include2ignore/search.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require_relative 'include'
+require_relative 'warnings'
+
+
+module Include2Ignore
+  # Directory tree traversal to find files and decide what to do.
+  module Search
+    DIR_SYMLINK_HANDLING = %i[reject skip check follow].freeze
+    @@dir_symlink_handling = DIR_SYMLINK_HANDLING.last
+    def self.dir_symlink_handling
+      @@dir_symlink_handling
+    end
+
+    def self.dir_symlink_handling=(value)
+      raise ArgumentError, "Include2Ignore::Search::dir_symlink_handling: not in #{DIR_SYMLINK_HANDLING.join(', ')}: #{value}" unless DIR_SYMLINK_HANDLING.include?(value)
+      @@dir_symlink_handling = value
+    end
+
+    FILE_SYMLINK_HANDLING = %i[reject skip check].freeze
+    @@file_symlink_handling = FILE_SYMLINK_HANDLING.last
+    def self.file_symlink_handling
+      @@file_symlink_handling
+    end
+
+    def self.file_symlink_handling=(value)
+      raise ArgumentError, "Include2Ignore::Search::file_symlink_handling: not in #{FILE_SYMLINK_HANDLING.join(', ')}: #{value}" unless FILE_SYMLINK_HANDLING.include?(value)
+      @@file_symlink_handling = value
+    end
+
+    def self.doc
+      <<EOF
+Symbolic link handling:
+- reject: Always ignore.
+- skip: Do not test, do not follow directory symlinks.
+- check: Check against rules but do not follow directory symlinks.
+- follow: Check and follow directory symlinks.
+EOF
+    end
+
+    # Helper class for Traverser.
+    class TraversalEntry
+      include Comparable
+
+      attr_reader :name, :full_name, :stat, :handle
+
+      def initialize(name, full_name)
+        @name = name
+        @full_name = full_name
+        @stat = File.lstat(full_name)
+        if @stat.symlink?
+          begin
+            @stat = File.stat(full_name)
+            if @stat.directory?
+              @handle = Search.dir_symlink_handling
+              if @handle == :follow
+                @full_name = File.realdirpath(full_name)
+              end
+            else
+              @handle = Search.file_symlink_handling
+            end
+          rescue Errno::ENOENT
+            Include2Ignore::Warnings.warn("Symlink broken: #{full_name}", true)
+            @handle = :reject
+          rescue Errno::ELOOP
+            Include2Ignore::Warnings.warn("Symlink loop: #{full_name}", true)
+            @handle = :reject
+          end
+        elsif @stat.directory?
+          @handle = :follow
+          @full_name = File.realdirpath(full_name)
+        else
+          @handle = :check
+        end
+      end
+
+      def directory?
+        @stat.directory? && @handle == :follow
+      end
+
+      def skip?
+        @handle == :skip
+      end
+
+      def reject?
+        @handle == :reject
+      end
+
+      def ino
+        @stat.ino
+      end
+
+      def path_name
+        @name.nil? ? @full_name : @name
+      end
+    end
+
+    def self.traverser(path_parts, skip, &block)
+      full_dir = File.join(path_parts.map(&:path_name))
+      dir = Dir.new(full_dir)
+      dir.each_child.map do |name|
+        full_name = File.join(full_dir, name)
+        t = TraversalEntry.new(name, full_name)
+        next if t.skip? # Should yield something to simplify testing.
+        path_parts.push(t)
+        # If skip rules explicitly include, then we skip.
+        names = path_parts[1..].map(&:name)
+        s = skip.exclude(names, t.directory? ? Include2Ignore::Include::DIR : Include2Ignore::Include::FILE)
+        if s.nil? || s
+          yield(names, t.directory?, t.reject?)
+          if t.directory? && path_parts.map(&:ino).index(t.ino) == path_parts.size - 1
+            traverser(path_parts, skip, &block)
+          end
+        end
+        path_parts.pop
+      end
+    end
+
+    def self.traverse(basedir, skip, &)
+      Search.traverser([ TraversalEntry.new(nil, basedir) ], skip, &)
+    end
+  end
+end

data/lib/include2ignore/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+# Name and version.
+module Include2Ignore
+  NAME = 'include2ignore'
+  VERSION = '0.1.0'
+end

data/lib/include2ignore/warnings.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require 'singleton'
+
+
+module Include2Ignore
+  # Allows higher-level code to set context, lower-level to display warnings.
+  # Usage:
+  # At top level where verbosity is set: Include2Ignore::Warnings.output_explanations(verbosity)
+  # At level where location is known: Include2Ignore::Warnings.where(description)
+  # At lower level where warnings or other are found:
+  # Output always: Include2Ignore::Warnings.warn(message)
+  # Output only when verbose: Include2Ignore::Warnings.explain(message)
+  class Warnings
+    include Singleton
+
+    attr_reader :context
+    attr_accessor :verbose, :output
+
+    def self.output(nil_or_has_puts_string)
+      Warnings.instance.output = nil_or_has_puts_string
+    end
+
+    def where(location)
+      @context = location
+    end
+
+    def self.where(location)
+      Warnings.instance.where(location)
+    end
+
+    def warn(message, omit_context = false)
+      @output = $stderr if @output.nil?
+      if omit_context
+        @output.puts(message)
+      else
+        @output.puts(@context) unless @context.nil?
+        @context = nil
+        @output.puts("  #{message}")
+      end
+    end
+
+    def self.warn(message, omit_context = false)
+      Warnings.instance.warn(message, omit_context)
+    end
+
+    def self.output_explanations(verbose)
+      Warnings.instance.verbose = verbose
+    end
+
+    def explain(message)
+      warn(message) if @verbose
+    end
+
+    def self.explain(message)
+      Warnings.instance.explain(message)
+    end
+  end
+end

data/lib/include2ignore.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Copyright © 2026 Ismo Kärkkäinen
+# Licensed under Universal Permissive License. See LICENSE.txt.
+
+require_relative 'include2ignore/config'
+require_relative 'include2ignore/ignore'
+require_relative 'include2ignore/include'
+require_relative 'include2ignore/search'
+require_relative 'include2ignore/version'
+require_relative 'include2ignore/warnings'

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: include2ignore
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ismo Kärkkäinen
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Takes a list of file names or patterns, finds all files that do not match any
+  of them, or only match exclude patterns in the input file, and outputs them.
+  If directory contains no files that are included, outputs the directory
+  instead of individual files.
+email: ismokarkkainen@icloud.com
+executables:
+- include2ignore
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- bin/include2ignore
+- lib/include2ignore.rb
+- lib/include2ignore/config.rb
+- lib/include2ignore/ignore.rb
+- lib/include2ignore/include.rb
+- lib/include2ignore/search.rb
+- lib/include2ignore/version.rb
+- lib/include2ignore/warnings.rb
+homepage: https://xn--ismo-krkkinen-gfbd.fi/include2ignore/index.html
+licenses:
+- UPL-1.0
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.21
+specification_version: 4
+summary: Reads include file, finds files under directory, and outputs ignore file.
+test_files: []