copy_code 0.3.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a4d333eaa0ad272d522245a8da8924bb4735f2579bf1820b5e4698ab8eeb1b99
+  data.tar.gz: b750c71bd022f0630007266b73a3f0781d693722d4ccfbca6c840b9c4137e00a
+SHA512:
+  metadata.gz: 1c14cafc2fd57a0c6d32ce6b9e73c527909a245b9ea11e49be207e835618132db32a55ec52831f5fec29b385a9c9a2b533dbff6f1b924a583748ccbffd98fedf
+  data.tar.gz: a6456aa45e75e3529f623c0d4ae4b110623e0dbb939254f86ec1a0a1df56bacc97ac8ca6200f59946741c43e43b64336eb9af074b37400b6a2ca08f138b45444

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright (c) 2025 t0nylombardi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall 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/README.md

@@ -0,0 +1,114 @@
+# 🧠 copy_code
+
+![Gem Version](https://img.shields.io/gem/v/copy_code.svg)
+![Ruby](https://img.shields.io/badge/ruby-3.0%2B-red)
+![Build Status](https://img.shields.io/github/actions/workflow/status/t0nylombardi/copy_code/test.yml?branch=main)
+![Code Style](https://img.shields.io/badge/code%20style-rubocop-brightgreen)
+
+A smart, flexible CLI tool to copy source code from a directory (or project) into your clipboard or a text file — while skipping unnecessary files using `.ccignore`.
+
+---
+
+## 🔧 Features
+
+- ✅ Recursively finds source code files in a target directory
+- 🧹 Ignores folders like `.git`, `node_modules`, etc. using a `.copy_codeignore` file
+- 🎯 Filters by file extension (`--extensions=rb,py,js`)
+- 📋 Copies output to your clipboard or saves to a file (`--print=pbcopy|txt`)
+- 🐚 Works from the terminal with one clean command
+
+---
+
+### Options
+
+| flags                | options                                                              |
+| -------------------- | -------------------------------------------------------------------- |
+| -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)                  |
+| -h                   | Show help information                                                |
+
+## 🚀 Installation
+
+```sh
+gem install copy_code
+```
+
+Or clone and build manually:
+
+```sh
+git clone https://github.com/your_username/copy_code.git
+cd copy_code
+gem build copy_code.gemspec
+gem install ./copy_code-*.gem
+```
+
+## 🛠 Usage
+
+```sh
+copy_code [options] [paths]
+```
+
+### Examples
+
+Copy all .rb and .py files from the current directory and subdirectories:
+
+```sh
+copy_code -e rb,py
+```
+
+Copy .js, .ts, and .json files from a specific folder and write to a file:
+
+```sh
+copy_code ~/projects/my-app -e js,ts,json -p txt
+```
+
+Copy all .rb and .py files from the current directory and subdirectories:
+
+```sh
+copy_code -e rb,py
+```
+
+Copy .js, .ts, and .json files from a specific folder and write to a file:
+
+```sh
+copy_code ~/projects/my-app -e js,ts,json -p txt
+```
+
+```sh
+copy_code -e rb,py
+```
+
+Copy .js, .ts, and .json files from a specific folder and write to a file:
+
+```sh
+copy_code ~/projects/my-app -e js,ts,json -p txt
+```
+
+```sh
+copy_code -e rb,py
+```
+
+### 📂 .ccignore
+
+You can create a `.ccignore` file in your project directory to specify files and directories to ignore. This works similarly to `.gitignore`.
+
+### Example `.ccignore` file
+
+```
+# Ignore all node_modules directories
+node_modules/
+# Ignore all .git directories
+.git/
+# Ignore all log files
+*.log
+# Ignore all temporary files
+*.tmp
+# Ignore all coverage directories
+coverage/
+# Ignore all virtual environments
+.venv/
+```
+
+## 📜 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "code_copy"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/copy_code

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require_relative "../lib/copy_code"
+
+CopyCode::CLI::Runner.run(ARGV)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/copy_code/cli/ignore_loader.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# 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.
+#
+# It checks the first project target path passed to the CLI, and falls back
+# to the user's `~/.ccignore` if not found.
+
+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.
+    class IgnoreLoader
+      # @param ignore_patterns [Array<String>] substrings to match in file paths
+      def initialize(ignore_patterns = [])
+        @patterns = ignore_patterns || []
+      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
+      def self.load(target_path)
+        local_file = File.join(target_path, ".ccignore")
+        fallback_file = File.expand_path("~/.ccignore")
+
+        file = File.exist?(local_file) ? local_file : fallback_file
+        return [] unless File.exist?(file)
+
+        lines = File.readlines(file).map(&:strip)
+        lines.reject!(&:empty?)
+        lines || []
+      end
+
+      # @param file [String]
+      # @return [Boolean] whether the file should be excluded
+      def exclude?(file)
+        @patterns.any? { |pattern| file.include?("/#{pattern}/") }
+      end
+    end
+  end
+end

data/lib/copy_code/cli/output_writer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# This file defines the CopyCode::CLI::OutputWriter class, which is responsible
+# for outputting formatted code content to either:
+#   - The clipboard (using macOS `pbcopy`)
+#   - A text file named `code_output.txt`
+#
+# Output method is selected via CLI flag `-p txt|pbcopy`.
+
+module CopyCode
+  module CLI
+    # OutputWriter handles writing the final formatted code string
+    # to the destination selected by the user (`pbcopy` or `txt`).
+    #
+    # If `txt` is specified, the content is saved to `code_output.txt`.
+    # If no method or `pbcopy` is specified, the content is copied to the clipboard
+    # using macOS `pbcopy` via `IO.popen`.
+    class OutputWriter
+      # Writes the given content to the selected output method.
+      #
+      # @param content [String] the fully formatted output content
+      # @param method [String] the output method ("txt" or "pbcopy")
+      # @return [void]
+      def self.write(content, method)
+        case method
+        when "txt"
+          File.write("code_output.txt", content)
+          puts "✅ Saved to code_output.txt"
+        else
+          IO.popen("pbcopy", "w") { |io| io.write(content) }
+          puts "✅ Copied to clipboard"
+        end
+      end
+    end
+  end
+end

data/lib/copy_code/cli/parser.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module CopyCode
+  module CLI
+    # Parser handles CLI argument parsing and validation for the CopyCode CLI tool.
+    #
+    # It processes flags like:
+    # - `-e` to specify file extensions
+    # - `-p` to control output format (clipboard or text file)
+    # and any paths passed to the command.
+    #
+    # Usage:
+    #   parser = CopyCode::CLI::Parser.new(ARGV)
+    #   options = parser.parse
+    #
+    # Returns an options hash:
+    # {
+    #   extensions: ['rb', 'py'],
+    #   output: 'txt',
+    #   targets: ['/full/path/to/project']
+    # }
+    class Parser
+      # @param argv [Array<String>] The raw arguments passed from the command line
+      def initialize(argv)
+        @argv = argv
+        @options = {
+          extensions: [],
+          output: "pbcopy",
+          targets: []
+        }
+      end
+
+      # Parses the provided arguments and returns a validated options hash.
+      #
+      # @return [Hash] Parsed and validated options including :extensions, :output, and :targets
+      def parse
+        build_parser.parse!(@argv)
+        assign_targets
+        validate_targets
+        @options
+      end
+
+      private
+
+      # Builds the OptionParser instance that parses CLI flags.
+      #
+      # @return [OptionParser]
+      def build_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: copy_code [options] [paths]"
+          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
+        end
+      end
+
+      # Parses the extensions string passed from the CLI flag.
+      #
+      # @param raw [String] Comma-separated list of extensions
+      # @return [Array<String>] Cleaned list of extensions
+      def parse_extensions(raw)
+        raw.split(",").map(&:strip)
+      end
+
+      # Expands and assigns the target paths passed as positional args.
+      #
+      # @return [void]
+      def assign_targets
+        @options[:targets] = @argv unless @argv.empty?
+        @options[:targets].map! { |t| File.expand_path(t) }
+      end
+
+      # Validates each target path and warns if any don't exist.
+      #
+      # @return [void]
+      def validate_targets
+        @options[:targets].each do |path|
+          warn "[WARN] Target path does not exist: #{path}" unless Dir.exist?(path)
+        end
+      end
+    end
+  end
+end

data/lib/copy_code/cli.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# copy_code/lib/copy_code/cli/runner.rb
+#
+# This file defines the CopyCode::CLI::Runner class, which is the core orchestrator
+# for the command-line execution of the copy_code tool.
+#
+# The Runner is responsible for:
+# - Parsing CLI arguments
+# - Loading ignore patterns
+# - Constructing file filters
+# - Discovering and formatting files
+# - Writing the result to either clipboard or a text file
+#
+# It separates the CLI runtime flow from the CLI namespace (CopyCode::CLI),
+# following SOLID and DDD principles.
+
+module CopyCode
+  module CLI
+    # Runner executes the core command flow of the CopyCode CLI.
+    #
+    # It acts as a controller between CLI argument parsing,
+    # file discovery, formatting, and output.
+    class Runner
+      # @param argv [Array<String>] the raw arguments passed from the command line
+      def initialize(argv)
+        @argv = argv
+      end
+
+      def self.run(argv)
+        new(argv).execute
+      end
+
+      # Executes the complete CLI flow: parse → filter → format → output.
+      #
+      # @return [void]
+      def execute
+        OutputWriter.write(result, options[:output])
+      end
+
+      private
+
+      # Constructs all filters to apply during file discovery.
+      #
+      # @return [Array<#exclude?>] array of filter objects
+      def filters
+        @filters ||= [
+          Filters::FileExtensionFilter.new(options[:extensions]),
+          Filters::IgnorePathFilter.new(IgnoreLoader.load(options[:targets].first))
+        ]
+      end
+
+      # Creates the core file discovery/formatting engine.
+      #
+      # @return [CopyCode::Core]
+      def core
+        @core ||= Core.new(
+          targets: options[:targets],
+          filters: filters
+        )
+      end
+
+      # Retrieves the list of matching files from the core engine.
+      #
+      # @return [Array<String>] list of file paths
+      def files
+        @files ||= core.gather_files
+      end
+
+      # Formats the gathered files into a single output string.
+      #
+      # @return [String] formatted code content
+      def result
+        @result ||= core.format(files)
+      end
+
+      # Parses the command-line arguments using the CLI parser.
+      #
+      # @return [Hash] parsed options hash
+      def options
+        @options ||= Parser.new(@argv).parse
+      end
+    end
+  end
+end

data/lib/copy_code/core.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "pry"
+
+module CopyCode
+  # Core file aggregator and formatter for the CopyCode domain
+  class Core
+    # @param targets [Array<String>] directories or files to scan
+    # @param filters [Array<#exclude?>] list of objects responding to `exclude?(file)`
+    def initialize(targets:, filters: [])
+      @targets = targets.empty? ? ["."] : targets
+      @filters = filters
+    end
+
+    # Gathers all matching files from the given targets.
+    #
+    # @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
+      end
+    end
+
+    # Formats the given files into output chunks with headers
+    #
+    # @param files [Array<String>] list of file paths
+    # @return [String] formatted text
+    def format(files)
+      files.map do |file|
+        header = "=== #{file} ==="
+        content = File.read(file)
+        "#{header}\n#{content}\n"
+      end.join("\n")
+    end
+
+    private
+
+    def include_file?(file)
+      @filters.none? { |f| f.exclude?(file) }
+    end
+  end
+end

data/lib/copy_code/filters/file_extension_filter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CopyCode
+  module Filters
+    # Filters files by allowed extension
+    class FileExtensionFilter
+      # @param extensions [Array<String>] file extensions without dot (e.g., "rb", "js")
+      def initialize(extensions)
+        @extensions = extensions.map { |ext| ".#{ext.gsub(/^\./, "")}" }
+      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) }
+      end
+    end
+  end
+end

data/lib/copy_code/filters/ignore_path_filter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CopyCode
+  module Filters
+    # Filters files by path substrings (e.g., ".venv", "node_modules")
+    class IgnorePathFilter
+      # @param ignore_patterns [Array<String>] substrings to match in file paths
+      def initialize(ignore_patterns)
+        @patterns = ignore_patterns
+      end
+
+      # @param file [String]
+      # @return [Boolean] whether the file should be excluded
+      def exclude?(file)
+        @patterns.any? { |pattern| file.include?("/#{pattern}/") }
+      end
+    end
+  end
+end

data/lib/copy_code/version.rb

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

data/lib/copy_code.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "copy_code/version"
+require_relative "copy_code/cli"
+require_relative "copy_code/core"
+
+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

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: copy_code
+version: !ruby/object:Gem::Version
+  version: 0.3.0.beta
+platform: ruby
+authors:
+- t0nylombardi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Find and copy code files from a project, with ignore rules and output
+  options
+email:
+- alombardi.331@gmail.com
+executables:
+- console
+- copy_code
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/copy_code
+- bin/setup
+- lib/copy_code.rb
+- lib/copy_code/cli.rb
+- lib/copy_code/cli/ignore_loader.rb
+- lib/copy_code/cli/output_writer.rb
+- lib/copy_code/cli/parser.rb
+- lib/copy_code/core.rb
+- lib/copy_code/filters/file_extension_filter.rb
+- lib/copy_code/filters/ignore_path_filter.rb
+- lib/copy_code/version.rb
+homepage: https://github.com/t0nylombardi/copy_code
+licenses:
+- MIT
+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
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: CLI tool to copy code from a directory
+test_files: []