copy_code 0.3.0.beta → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4d333eaa0ad272d522245a8da8924bb4735f2579bf1820b5e4698ab8eeb1b99
-  data.tar.gz: b750c71bd022f0630007266b73a3f0781d693722d4ccfbca6c840b9c4137e00a
+  metadata.gz: 02ec338e62fcb51c5376e10f75ba426814a591a994c8b9e3f2fd7471f02807f0
+  data.tar.gz: 758322b549d523a450ece9e8bec80ff4fba3cfc7014ab26a4f0f4e529612fa2b
 SHA512:
-  metadata.gz: 1c14cafc2fd57a0c6d32ce6b9e73c527909a245b9ea11e49be207e835618132db32a55ec52831f5fec29b385a9c9a2b533dbff6f1b924a583748ccbffd98fedf
-  data.tar.gz: a6456aa45e75e3529f623c0d4ae4b110623e0dbb939254f86ec1a0a1df56bacc97ac8ca6200f59946741c43e43b64336eb9af074b37400b6a2ca08f138b45444
+  metadata.gz: b23b134e6dc1b70a4aa3e50a3da9e581e8534efc82597bd69ba459618f241805e0b6185bb259dbdbafa697f9a29181a294fa39e8fcec48f68e38bf179512ecc4
+  data.tar.gz: c86b884001aa6ca983fa29445625693bc2909b6d5bd33a0cb8a1410267518cacf82a2f747f23d2112d6cb54f5ac744c7a9c0dbd3a2216d3ec099a02dbef61d4f

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on Keep a Changelog, and this project adheres to SemVer.
+
+## [0.5.0] - 2026-01-12
+### Added
+- CLI flag `-o/--output-path` to control where text output is written.
+- Aruba RSpec integration specs for the CLI.
+- SimpleCov startup to measure coverage.
+- Support for `.cc_ignore` as an alternate ignore file name.
+
+### Changed
+- Text output defaults to the project root when the target is a file.
+- CLI now validates `-p/--print` values and errors on invalid output methods.
+- CLI now errors when a target path does not exist.
+
+### Fixed
+- Directory ignore rules now match directory paths and nested contents.
+- Directory glob rules now handle `**/` patterns correctly.
+- Ignore filtering leaves files outside the root unfiltered.
+- Relative path resolution returns absolute paths for files outside the root.
+- Core now supports file targets in addition to directories.
+- `pbcopy` fallback now warns and writes to stdout when unavailable.
+- Gemspec no longer packages built `.gem` artifacts.

data/README.md

@@ -25,6 +25,7 @@ A smart, flexible CLI tool to copy source code from a directory (or project) int
 | -------------------- | -------------------------------------------------------------------- |
 | -e, --extensions=EXT | Comma-separated list of file extensions to include (e.g. `-e rb,py`) |
 | -p, --print=OUT      | Output format: `pbcopy` (clipboard) or `txt` (file)                  |
+| -o, --output-path=PATH | Output path or directory for `txt` mode (default: `code_output.txt`) |
 | -h                   | Show help information                                                |
 
 ## 🚀 Installation
@@ -62,6 +63,18 @@ Copy .js, .ts, and .json files from a specific folder and write to a file:
 copy_code ~/projects/my-app -e js,ts,json -p txt
 ```
 
+Write output to a specific file:
+
+```sh
+copy_code ~/projects/my-app -e rb -p txt -o ~/tmp/my_code.txt
+```
+
+Write output to the project root:
+
+```sh
+copy_code ~/projects/my-app -e rb -p txt -o .
+```
+
 Copy all .rb and .py files from the current directory and subdirectories:
 
 ```sh

data/lib/copy_code/cli/ignore_loader.rb

@@ -3,43 +3,66 @@
 # copy_code/lib/copy_code/cli/ignore_loader.rb
 #
 # This file defines the CopyCode::CLI::IgnoreLoader class, which is responsible
-# for loading ignore patterns from a `.copy_codeignore` file.
+# for loading ignore patterns from `.ccignore` or `.cc_ignore`.
 #
 # It checks the first project target path passed to the CLI, and falls back
-# to the user's `~/.ccignore` if not found.
+# to the user's `~/.ccignore` or `~/.cc_ignore` if not found.
+
+require_relative "../filters/ignore_path_filter"
 
 module CopyCode
   module CLI
-    # IgnoreLoader loads a list of path substrings from a `.ccignore` file.
-    # It will attempt to read from the first provided target path.
-    #
-    # If no ignore file exists in that path, it will fall back to ~/.ccignore.
+    # IgnoreLoader loads ignore patterns from a `.ccignore` file, falling back to
+    # the user's `~/.ccignore`. The result includes the directory the patterns
+    # should be evaluated relative to.
     class IgnoreLoader
+      Result = Struct.new(:patterns, :base_dir, keyword_init: true)
+
       # @param ignore_patterns [Array<String>] substrings to match in file paths
-      def initialize(ignore_patterns = [])
+      def initialize(ignore_patterns = [], base_dir: Dir.pwd)
         @patterns = ignore_patterns || []
+        @base_dir = base_dir
       end
 
       # Loads ignore patterns from a given target directory or fallback path.
       #
       # @param target_path [String] the root of the scanned project
-      # @return [Array<String>] a list of path substrings to ignore
+      # @return [Result] a result containing patterns and the base directory
       def self.load(target_path)
-        local_file = File.join(target_path, ".ccignore")
-        fallback_file = File.expand_path("~/.ccignore")
+        target_path = File.expand_path(target_path)
+        local_file = first_existing_file(target_path, [".ccignore", ".cc_ignore"])
+        fallback_file = first_existing_file(File.expand_path("~"), [".ccignore", ".cc_ignore"])
+
+        file = local_file || fallback_file
+        base_dir = file ? File.dirname(file) : target_path
+        patterns = []
 
-        file = File.exist?(local_file) ? local_file : fallback_file
-        return [] unless File.exist?(file)
+        if file && File.exist?(file)
+          patterns = File.readlines(file, chomp: true)
+          patterns.map!(&:strip)
+          patterns.reject!(&:empty?)
+          patterns.reject! { |line| line.start_with?("#") }
+        end
 
-        lines = File.readlines(file).map(&:strip)
-        lines.reject!(&:empty?)
-        lines || []
+        Result.new(patterns: patterns, base_dir: base_dir)
       end
 
       # @param file [String]
       # @return [Boolean] whether the file should be excluded
       def exclude?(file)
-        @patterns.any? { |pattern| file.include?("/#{pattern}/") }
+        Filters::IgnorePathFilter.new(@patterns, root: @base_dir).exclude?(file)
+      end
+
+      # @param base_dir [String]
+      # @param names [Array<String>]
+      # @return [String, nil] the first existing file path
+      def self.first_existing_file(base_dir, names)
+        names.each do |name|
+          path = File.join(base_dir, name)
+          return path if File.exist?(path)
+        end
+
+        nil
       end
     end
   end

data/lib/copy_code/cli/output_writer.rb

@@ -20,17 +20,30 @@ module CopyCode
       #
       # @param content [String] the fully formatted output content
       # @param method [String] the output method ("txt" or "pbcopy")
+      # @param output_path [String, nil] optional path for text file output
       # @return [void]
-      def self.write(content, method)
-        case method
+      def self.write(content, method, output_path: nil)
+        normalized_method = method.to_s.strip.downcase
+        case normalized_method
         when "txt"
-          File.write("code_output.txt", content)
-          puts "✅ Saved to code_output.txt"
+          path = output_path || "code_output.txt"
+          File.write(path, content)
+          puts "✅ Saved to #{path}"
         else
-          IO.popen("pbcopy", "w") { |io| io.write(content) }
-          puts "✅ Copied to clipboard"
+          if pbcopy_available?
+            IO.popen("pbcopy", "w") { |io| io.write(content) }
+            puts "✅ Copied to clipboard"
+          else
+            warn "[WARN] pbcopy not available; writing to stdout"
+            puts content
+          end
         end
       end
+
+      def self.pbcopy_available?
+        system("command", "-v", "pbcopy", out: File::NULL, err: File::NULL)
+      end
+      private_class_method :pbcopy_available?
     end
   end
 end

data/lib/copy_code/cli/parser.rb

@@ -28,6 +28,7 @@ module CopyCode
         @options = {
           extensions: [],
           output: "pbcopy",
+          output_path: nil,
           targets: []
         }
       end
@@ -39,6 +40,7 @@ module CopyCode
         build_parser.parse!(@argv)
         assign_targets
         validate_targets
+        normalize_output
         @options
       end
 
@@ -49,13 +51,20 @@ module CopyCode
       # @return [OptionParser]
       def build_parser
         OptionParser.new do |opts|
-          opts.banner = "Usage: copy_code [options] [paths]"
+          opts.banner = "Usage: copy_code [paths] [options]"
           opts.on("-eEXT", "--extensions=EXT", "Comma-separated list (e.g. rb,py,js)") do |ext|
             @options[:extensions] = parse_extensions(ext)
           end
           opts.on("-pOUT", "--print=OUT", "Output method: pbcopy (default) or txt") do |out|
             @options[:output] = out
           end
+          opts.on("-oPATH", "--output-path=PATH", "Path or directory for txt output (default: code_output.txt)") do |path|
+            @options[:output_path] = path
+          end
+          opts.on("-h", "--help", "Displays help information") do
+            puts opts
+            exit
+          end
         end
       end
 
@@ -71,7 +80,7 @@ module CopyCode
       #
       # @return [void]
       def assign_targets
-        @options[:targets] = @argv unless @argv.empty?
+        @options[:targets] = @argv.empty? ? [Dir.pwd] : @argv
         @options[:targets].map! { |t| File.expand_path(t) }
       end
 
@@ -80,9 +89,18 @@ module CopyCode
       # @return [void]
       def validate_targets
         @options[:targets].each do |path|
-          warn "[WARN] Target path does not exist: #{path}" unless Dir.exist?(path)
+          next if File.exist?(path)
+
+          raise OptionParser::InvalidArgument, "Target path does not exist: #{path}"
         end
       end
+
+      def normalize_output
+        @options[:output] = @options[:output].to_s.strip.downcase
+        return if %w[pbcopy txt].include?(@options[:output])
+
+        raise OptionParser::InvalidArgument, "Output must be pbcopy or txt"
+      end
     end
   end
 end

data/lib/copy_code/cli.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 # copy_code/lib/copy_code/cli/runner.rb
 #
 # This file defines the CopyCode::CLI::Runner class, which is the core orchestrator
@@ -35,7 +37,7 @@ module CopyCode
       #
       # @return [void]
       def execute
-        OutputWriter.write(result, options[:output])
+        OutputWriter.write(result, options[:output], output_path: output_path)
       end
 
       private
@@ -44,10 +46,16 @@ module CopyCode
       #
       # @return [Array<#exclude?>] array of filter objects
       def filters
-        @filters ||= [
-          Filters::FileExtensionFilter.new(options[:extensions]),
-          Filters::IgnorePathFilter.new(IgnoreLoader.load(options[:targets].first))
-        ]
+        @filters ||= begin
+          ignore_config = IgnoreLoader.load(options[:targets].first)
+          [
+            Filters::FileExtensionFilter.new(options[:extensions]),
+            Filters::IgnorePathFilter.new(
+              ignore_config.patterns,
+              root: ignore_config.base_dir
+            )
+          ]
+        end
       end
 
       # Creates the core file discovery/formatting engine.
@@ -80,6 +88,31 @@ module CopyCode
       def options
         @options ||= Parser.new(@argv).parse
       end
+
+      # Determines where to write the text output, if requested.
+      #
+      # @return [String, nil] absolute output path or nil when not writing a file
+      def output_path
+        return nil unless options[:output].to_s.strip.casecmp("txt").zero?
+
+        explicit_path = options[:output_path]
+        target = options[:targets].first
+        base_dir = File.directory?(target) ? target : Dir.pwd
+        return File.join(base_dir, "code_output.txt") if explicit_path.nil? || explicit_path.strip.empty?
+
+        resolved_path = File.expand_path(explicit_path, base_dir)
+        return File.join(resolved_path, "code_output.txt") if directory_like?(explicit_path, resolved_path)
+
+        resolved_path
+      end
+
+      def directory_like?(explicit_path, resolved_path)
+        return true if explicit_path.end_with?(File::SEPARATOR)
+        return true if [".", ".."].include?(explicit_path)
+        return true if File.directory?(resolved_path)
+
+        false
+      end
     end
   end
 end

data/lib/copy_code/core.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "pry"
-
 module CopyCode
   # Core file aggregator and formatter for the CopyCode domain
   class Core
@@ -17,11 +15,7 @@ module CopyCode
     # @return [Array<String>] list of absolute file paths
     def gather_files
       @targets.flat_map do |target|
-        Dir.glob("#{target}/**/*", File::FNM_DOTMATCH).select do |file|
-          is_file = File.file?(file)
-          is_included = include_file?(file)
-          is_file && is_included
-        end
+        files_for_target(target).select { |file| include_file?(file) }
       end
     end
 
@@ -39,6 +33,13 @@ module CopyCode
 
     private
 
+    def files_for_target(target)
+      return [target] if File.file?(target)
+      return [] unless File.directory?(target)
+
+      Dir.glob("#{target}/**/*", File::FNM_DOTMATCH).select { |file| File.file?(file) }
+    end
+
     def include_file?(file)
       @filters.none? { |f| f.exclude?(file) }
     end

data/lib/copy_code/domain/filtering/ignore_rule.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module CopyCode
+  module Domain
+    module Filtering
+      # IgnoreRule represents a single gitignore-style rule.
+      class IgnoreRule
+        MATCH_OPTIONS = File::FNM_PATHNAME | File::FNM_EXTGLOB
+
+        def self.from(raw_pattern)
+          pattern = raw_pattern.to_s.strip
+          return if pattern.empty?
+
+          new(pattern)
+        end
+
+        def initialize(pattern)
+          @negated = pattern.start_with?("!")
+          pattern = pattern[1..] if @negated
+
+          @directory_only = pattern.end_with?("/")
+          pattern = pattern.chomp("/")
+
+          @anchored = pattern.start_with?("/")
+          pattern = pattern.sub(%r{\A/+}, "")
+
+          @pattern = pattern
+          @globs = compile_globs(pattern)
+        end
+
+        # Applies the rule to the provided path, returning the updated ignored state.
+        #
+        # @param path [String] relative path from the project root
+        # @param ignored [Boolean] current ignored state
+        # @return [Boolean] new ignored state
+        def apply(path, ignored)
+          return ignored unless matches?(path)
+
+          @negated ? false : true
+        end
+
+        private
+
+        def matches?(path)
+          return false if @globs.empty?
+
+          return directory_match?(path) if @directory_only
+
+          @globs.any? { |glob| File.fnmatch?(glob, path, MATCH_OPTIONS) }
+        end
+
+        def compile_globs(pattern)
+          return [] if pattern.nil? || pattern.empty?
+
+          base = if @anchored
+            pattern
+          else
+            compile_unanchored(pattern)
+          end
+
+          glob_variants(base)
+        end
+
+        def compile_unanchored(pattern)
+          pattern.start_with?("**/") ? pattern : "**/#{pattern}"
+        end
+
+        def glob_variants(base)
+          sanitized = base.gsub(%r{//+}, "/")
+
+          if @directory_only
+            [
+              sanitized,
+              "#{sanitized}/**"
+            ]
+          elsif base.include?("/")
+            [sanitized]
+          else
+            [
+              sanitized,
+              "#{sanitized}/**"
+            ]
+          end
+        end
+
+        def directory_match?(path)
+          return false if @pattern.nil? || @pattern.empty?
+
+          if glob_pattern?(@pattern)
+            return directory_glob_match?(path, @pattern)
+          end
+
+          if @anchored
+            return path == @pattern || path.start_with?("#{@pattern}/")
+          end
+
+          path.match?(%r{(^|/)#{Regexp.escape(@pattern)}(/|$)})
+        end
+
+        def directory_glob_match?(path, pattern)
+          sanitized_pattern = strip_leading_double_star(pattern)
+          regex = glob_to_regex(sanitized_pattern)
+          if @anchored
+            if pattern.start_with?("**/")
+              path.match?(%r{\A(?:.*/)?#{regex}(?:/|$)})
+            else
+              path.match?(%r{\A#{regex}(?:/|$)})
+            end
+          else
+            path.match?(%r{(^|/)#{regex}(?:/|$)})
+          end
+        end
+
+        def glob_to_regex(pattern)
+          regex = +""
+          index = 0
+
+          while index < pattern.length
+            char = pattern[index]
+            next_char = pattern[index + 1]
+
+            if char == "*" && next_char == "*"
+              regex << ".*"
+              index += 2
+              next
+            end
+
+            case char
+            when "*"
+              regex << "[^/]*"
+            when "?"
+              regex << "[^/]"
+            when "["
+              index = append_character_class(regex, pattern, index)
+            when "{"
+              index = append_brace_group(regex, pattern, index)
+            else
+              regex << Regexp.escape(char)
+            end
+
+            index += 1
+          end
+
+          regex
+        end
+
+        def append_character_class(regex, pattern, start_index)
+          closing = pattern.index("]", start_index + 1)
+          return append_literal(regex, pattern[start_index], start_index) unless closing
+
+          content = pattern[(start_index + 1)...closing]
+          if content.start_with?("!")
+            content = "^" + Regexp.escape(content[1..])
+          else
+            content = Regexp.escape(content)
+          end
+
+          regex << "[#{content}]"
+          closing
+        end
+
+        def append_brace_group(regex, pattern, start_index)
+          closing = pattern.index("}", start_index + 1)
+          return append_literal(regex, pattern[start_index], start_index) unless closing
+
+          content = pattern[(start_index + 1)...closing]
+          parts = content.split(",").map { |part| Regexp.escape(part) }
+          regex << "(?:#{parts.join("|")})"
+          closing
+        end
+
+        def append_literal(regex, char, index)
+          regex << Regexp.escape(char)
+          index
+        end
+
+        def glob_pattern?(value)
+          value.match?(/[?*\[\{]/)
+        end
+
+        def strip_leading_double_star(pattern)
+          pattern.start_with?("**/") ? pattern.delete_prefix("**/") : pattern
+        end
+      end
+    end
+  end
+end

data/lib/copy_code/domain/filtering/ignore_rule_set.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CopyCode
+  module Domain
+    module Filtering
+      # IgnoreRuleSet aggregates ordered ignore rules and evaluates them.
+      class IgnoreRuleSet
+        def initialize(patterns)
+          @rules = build_rules(patterns)
+        end
+
+        # @param path [String] relative path from the root
+        # @return [Boolean] whether the path should be ignored
+        def ignored?(path)
+          ignored = false
+          @rules.each do |rule|
+            ignored = rule.apply(path, ignored)
+          end
+          ignored
+        end
+
+        def empty?
+          @rules.empty?
+        end
+
+        private
+
+        def build_rules(patterns)
+          Array(patterns).filter_map do |pattern|
+            IgnoreRule.from(pattern)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/copy_code/domain/filtering/pattern_whitelist.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module CopyCode
+  module Domain
+    module Filtering
+      # PatternWhitelist encapsulates glob-based inclusion rules for filenames.
+      class PatternWhitelist
+        MATCH_OPTIONS = File::FNM_EXTGLOB | File::FNM_PATHNAME
+
+        def initialize(patterns)
+          @patterns = build_patterns(patterns)
+        end
+
+        # @param file [String]
+        # @return [Boolean] whether the file should be included by the whitelist
+        def include?(file)
+          return true if @patterns.empty?
+
+          basename = File.basename(file)
+          @patterns.any? { |pattern| File.fnmatch?(pattern, basename, MATCH_OPTIONS) }
+        end
+
+        private
+
+        def build_patterns(patterns)
+          Array(patterns).filter_map do |pattern|
+            normalized_pattern(pattern)
+          end
+        end
+
+        def normalized_pattern(raw)
+          value = raw.to_s.strip
+          return if value.empty?
+
+          return value if glob_pattern?(value)
+
+          normalized = value.sub(/\A\./, "")
+          "*.#{normalized}"
+        end
+
+        def glob_pattern?(value)
+          value.match?(/[?*\[\{]/)
+        end
+      end
+    end
+  end
+end

data/lib/copy_code/domain/filtering/relative_path_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module CopyCode
+  module Domain
+    module Filtering
+      # RelativePathResolver converts absolute file paths into paths relative to a root.
+      class RelativePathResolver
+        def initialize(root:)
+          @root = Pathname.new(File.expand_path(root || Dir.pwd))
+        end
+
+        # @param file [String]
+        # @return [String] the path relative to the configured root
+        def call(file)
+          file_path = Pathname.new(File.expand_path(file))
+          relative = file_path.relative_path_from(@root).to_s
+          return file_path.to_s if outside_root?(relative)
+
+          relative
+        rescue ArgumentError
+          file_path.to_s
+        end
+
+        private
+
+        def outside_root?(relative)
+          relative == ".." || relative.start_with?("..#{File::SEPARATOR}")
+        end
+      end
+    end
+  end
+end

data/lib/copy_code/domain/filtering.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "filtering/pattern_whitelist"
+require_relative "filtering/ignore_rule"
+require_relative "filtering/ignore_rule_set"
+require_relative "filtering/relative_path_resolver"
+
+module CopyCode
+  module Domain
+    module Filtering; end
+  end
+end

data/lib/copy_code/filters/file_extension_filter.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "../domain/filtering"
+
 module CopyCode
   module Filters
-    # Filters files by allowed extension
+    # Filters files by allowed extension or glob pattern, delegating to the domain whitelist.
     class FileExtensionFilter
       # @param extensions [Array<String>] file extensions without dot (e.g., "rb", "js")
       def initialize(extensions)
-        @extensions = extensions.map { |ext| ".#{ext.gsub(/^\./, "")}" }
+        @whitelist = Domain::Filtering::PatternWhitelist.new(extensions)
       end
 
       # @param file [String]
       # @return [Boolean] whether the file should be excluded
       def exclude?(file)
-        return false if @extensions.empty?
-
-        !@extensions.any? { |ext| file.end_with?(ext) }
+        !@whitelist.include?(file)
       end
     end
   end

data/lib/copy_code/filters/ignore_path_filter.rb

@@ -1,18 +1,28 @@
 # frozen_string_literal: true
 
+require "pathname"
+require_relative "../domain/filtering"
+
 module CopyCode
   module Filters
-    # Filters files by path substrings (e.g., ".venv", "node_modules")
+    # Filters files by gitignore-style path rules.
     class IgnorePathFilter
-      # @param ignore_patterns [Array<String>] substrings to match in file paths
-      def initialize(ignore_patterns)
-        @patterns = ignore_patterns
+      # @param ignore_patterns [Array<String>] gitignore-like patterns
+      # @param root [String] directory the patterns are relative to
+      def initialize(ignore_patterns, root:)
+        @resolver = Domain::Filtering::RelativePathResolver.new(root: root)
+        @rules = Domain::Filtering::IgnoreRuleSet.new(ignore_patterns)
       end
 
       # @param file [String]
       # @return [Boolean] whether the file should be excluded
       def exclude?(file)
-        @patterns.any? { |pattern| file.include?("/#{pattern}/") }
+        return false if @rules.empty?
+
+        relative = @resolver.call(file)
+        return false if Pathname.new(relative).absolute?
+
+        @rules.ignored?(relative)
       end
     end
   end

data/lib/copy_code/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CopyCode
-  VERSION = "0.3.0.beta"
+  VERSION = "0.5.0"
 end

data/lib/copy_code.rb

@@ -4,12 +4,11 @@ require_relative "copy_code/version"
 require_relative "copy_code/cli"
 require_relative "copy_code/core"
 
+require_relative "copy_code/domain/filtering"
 require_relative "copy_code/filters/file_extension_filter"
 require_relative "copy_code/filters/ignore_path_filter"
 require_relative "copy_code/cli/ignore_loader"
 require_relative "copy_code/cli/output_writer"
 require_relative "copy_code/cli/parser"
 
-module CopyCode
-  # maybe some top-level stuff here
-end
+module CopyCode; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: copy_code
 version: !ruby/object:Gem::Version
-  version: 0.3.0.beta
+  version: 0.5.0
 platform: ruby
 authors:
 - t0nylombardi
@@ -12,7 +12,7 @@ dependencies: []
 description: Find and copy code files from a project, with ignore rules and output
   options
 email:
-- alombardi.331@gmail.com
+- iam@t0nylombardi.com
 executables:
 - console
 - copy_code
@@ -20,6 +20,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
@@ -32,6 +33,11 @@ files:
 - lib/copy_code/cli/output_writer.rb
 - lib/copy_code/cli/parser.rb
 - lib/copy_code/core.rb
+- lib/copy_code/domain/filtering.rb
+- lib/copy_code/domain/filtering/ignore_rule.rb
+- lib/copy_code/domain/filtering/ignore_rule_set.rb
+- lib/copy_code/domain/filtering/pattern_whitelist.rb
+- lib/copy_code/domain/filtering/relative_path_resolver.rb
 - lib/copy_code/filters/file_extension_filter.rb
 - lib/copy_code/filters/ignore_path_filter.rb
 - lib/copy_code/version.rb
@@ -41,7 +47,6 @@ licenses:
 metadata:
   homepage_uri: https://github.com/t0nylombardi/copy_code
   source_code_uri: https://github.com/t0nylombardi/copy_code
-  changelog_uri: https://github.com/t0nylombardi/copy_code/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -56,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.6.9
 specification_version: 4
 summary: CLI tool to copy code from a directory
 test_files: []