poepod 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db687d7a65f167645bedbabce5082c8d254a70f891b493a7f900a4666b07dfc3
-  data.tar.gz: 159ed36950788d819b870a2f8d5e8d1e7c26103cdadc11702073bca959885711
+  metadata.gz: 3bc92cfee72702377260c08e2639cf32b789e54be73d3cea7896bde4bf357332
+  data.tar.gz: f79c5a7847f8329c2a1c5ef1718c97b7ce18852df727a5d92c2b58244da2a7c0
 SHA512:
-  metadata.gz: 53e110b148f0e78e7f9c257f18619f4c5718d01d390c8a604fd9a928349a25ca8840a26ac6130dc793f7687783732d360100c96195b88f83a2af20b58bed7723
-  data.tar.gz: 007e29ab64c3c3984aaef34a700fe3384c97d3f784f93cda466d8335252b979829b0373d7802737990bf8e65c618fa2e00fd46970a2345e57c35a24a33ddc05d
+  metadata.gz: 92da41a07f4007489ccba2dacd7a0e0eb194042916a3172d6b62a2e246a8d80eb364816ad0a5721157e1da5367071dfa34e5ca80c3e419ee2a81ddc609f17aa0
+  data.tar.gz: cd07a158aab095842892fbd8dd34154811be5d64d5bed0af27d3a085974a1955217ab7a1d445975c993ee30ffb57e57b679958d870785d98767babb7e18042f9

data/README.adoc

@@ -42,37 +42,62 @@ Commands:
   poepod wrap GEMSPEC_PATH           # Wrap a gem based on its gemspec file
 ----
 
+=== Global options
+
+All options can be used for both `wrap` and `concat` commands:
+
+* `--exclude`: List of patterns to exclude (default: `["node_modules/", ".git/", ".gitignore$", ".DS_Store$", "^\\..+"]`)
+* `--config`: Path to configuration file
+* `--include-binary`: Include binary files (encoded in MIME format)
+* `--include-dot-files`: Include dot files
+* `--output-file`: Output path
+* `--base-dir`: Base directory for relative file paths in output
+* `--include-unstaged`: Include unstaged files from `lib`, `spec`, and `test` directories (for `wrap` command only)
+
+[source,shell]
+----
+$ poepod concat FILES [OUTPUT_FILE] --exclude PATTERNS --config PATH --include-binary --include-dot-files --output-file PATH --base-dir PATH
+$ poepod wrap GEMSPEC_PATH --exclude PATTERNS --config PATH --include-binary --include-dot-files --output-file PATH --base-dir PATH --include-unstaged
+----
+
 === Concatenating files
 
 The `concat` command allows you to combine multiple files into a single text
-file. This is particularly useful when you want to review or analyze code from
+file.
+
+This is particularly useful when you want to review or analyze code from
 multiple files in one place, or when preparing code submissions for AI-powered
 coding assistants.
 
+By default, it excludes binary files, dot files, and certain patterns like
+`node_modules/` and `.git/`.
+
 [source,shell]
 ----
 $ poepod concat path/to/files/* output.txt
 ----
 
-This will concatenate all files from the specified path into `output.txt`.
+This will concatenate all non-binary, non-dot files from the specified path into
+`output.txt`.
 
-==== Excluding patterns
+==== Including dot files
 
-You can exclude certain patterns using the `--exclude` option:
+By default, dot files (hidden files starting with a dot) are excluded.
+
+To include them, use the `--include-dot-files` option:
 
 [source,shell]
 ----
-$ poepod concat path/to/files/* output.txt --exclude node_modules .git build test
+$ poepod concat path/to/files/* output.txt --include-dot-files
 ----
 
-This is helpful when you want to focus on specific parts of your codebase,
-excluding irrelevant or large directories.
-
 ==== Including binary files
 
 By default, binary files are excluded to keep the output focused on readable
-code. However, you can include binary files (encoded in MIME format) using the
-`--include-binary` option:
+code.
+
+To include binary files (encoded in MIME format), use the `--include-binary`
+option:
 
 [source,shell]
 ----
@@ -82,6 +107,18 @@ $ poepod concat path/to/files/* output.txt --include-binary
 This can be useful when you need to include binary assets or compiled files in
 your analysis.
 
+==== Excluding patterns
+
+You can exclude certain patterns using the `--exclude` option:
+
+[source,shell]
+----
+$ poepod concat path/to/files/* output.txt --exclude node_modules .git build test
+----
+
+This is helpful when you want to focus on specific parts of your codebase,
+excluding irrelevant or large directories.
+
 === Wrapping a gem
 
 The `wrap` command creates a comprehensive snapshot of your gem, including all

data/lib/poepod/cli.rb

@@ -1,49 +1,54 @@
+# lib/poepod/cli.rb
 # frozen_string_literal: true
 
-# lib/poepod/cli.rb
 require "thor"
 require_relative "file_processor"
 require_relative "gem_processor"
 
 module Poepod
+  # Command-line interface for Poepod
   class Cli < Thor
-    desc "concat FILES [OUTPUT_FILE]", "Concatenate specified files into one text file"
-    option :exclude, type: :array, default: Poepod::FileProcessor::EXCLUDE_DEFAULT, desc: "List of patterns to exclude"
-    option :config, type: :string, desc: "Path to configuration file"
-    option :include_binary, type: :boolean, default: false, desc: "Include binary files (encoded in MIME format)"
-
-    def concat(*files, output_file: nil)
-      if files.empty?
-        puts "Error: No files specified."
-        exit(1)
-      end
-
-      output_file ||= default_output_file(files.first)
-      output_path = Pathname.new(output_file).expand_path
+    # Define shared options
+    def self.shared_options
+      option :exclude, type: :array, default: nil,
+                       desc: "List of patterns to exclude"
+      option :config, type: :string, desc: "Path to configuration file"
+      option :include_binary, type: :boolean, default: false, desc: "Include binary files (encoded in MIME format)"
+      option :include_dot_files, type: :boolean, default: false, desc: "Include dot files"
+      option :output_file, type: :string, desc: "Output path"
+      option :base_dir, type: :string, desc: "Base directory for relative file paths in output"
+    end
 
-      processor = Poepod::FileProcessor.new(files, output_path, options[:config], options[:include_binary])
-      total_files, copied_files = processor.process
+    desc "concat FILES [OUTPUT_FILE]", "Concatenate specified files into one text file"
+    shared_options
 
-      puts "-> #{total_files} files detected."
-      puts "=> #{copied_files} files have been concatenated into #{output_path.relative_path_from(Dir.pwd)}."
+    def concat(*files)
+      check_files(files)
+      output_file = determine_output_file(files)
+      base_dir = options[:base_dir] || Dir.pwd
+      process_files(files, output_file, base_dir)
     end
 
     desc "wrap GEMSPEC_PATH", "Wrap a gem based on its gemspec file"
+    shared_options
     option :include_unstaged, type: :boolean, default: false,
                               desc: "Include unstaged files from lib, spec, and test directories"
 
     def wrap(gemspec_path)
-      processor = Poepod::GemProcessor.new(gemspec_path, nil, options[:include_unstaged])
-      success, result, unstaged_files = processor.process
-
+      base_dir = options[:base_dir] || File.dirname(gemspec_path)
+      output_file = options[:output_file] || File.join(base_dir, "#{File.basename(gemspec_path, ".*")}_wrapped.txt")
+      processor = Poepod::GemProcessor.new(
+        gemspec_path,
+        include_unstaged: options[:include_unstaged],
+        exclude: options[:exclude],
+        include_binary: options[:include_binary],
+        include_dot_files: options[:include_dot_files],
+        base_dir: base_dir,
+        config_file: options[:config],
+      )
+      success, result, unstaged_files = processor.process(output_file)
       if success
-        puts "=> The gem has been wrapped into '#{result}'."
-        if unstaged_files.any?
-          puts "\nWarning: The following files are not staged in git:"
-          puts unstaged_files
-          puts "\nThese files are #{options[:include_unstaged] ? "included" : "not included"} in the wrap."
-          puts "Use --include-unstaged option to include these files." unless options[:include_unstaged]
-        end
+        handle_wrap_result(success, result, unstaged_files)
       else
         puts result
         exit(1)
@@ -56,6 +61,54 @@ module Poepod
 
     private
 
+    def check_files(files)
+      return unless files.empty?
+
+      puts "Error: No files specified."
+      exit(1)
+    end
+
+    def determine_output_file(files)
+      options[:output_file] || default_output_file(files.first)
+    end
+
+    def process_files(files, output_file, base_dir)
+      output_path = Pathname.new(output_file).expand_path
+      processor = Poepod::FileProcessor.new(
+        files,
+        output_path,
+        config_file: options[:config],
+        include_binary: options[:include_binary],
+        include_dot_files: options[:include_dot_files],
+        exclude: options[:exclude],
+        base_dir: base_dir,
+      )
+      total_files, copied_files = processor.process(output_path.to_s)
+      print_result(total_files, copied_files, output_path)
+    end
+
+    def print_result(total_files, copied_files, output_path)
+      puts "-> #{total_files} files detected."
+      puts "=> #{copied_files} files have been concatenated into #{output_path.relative_path_from(Dir.pwd)}."
+    end
+
+    def handle_wrap_result(success, result, unstaged_files)
+      if success
+        puts "=> The gem has been wrapped into '#{result}'."
+        print_unstaged_files_warning(unstaged_files) if unstaged_files.any?
+      else
+        puts result
+        exit(1)
+      end
+    end
+
+    def print_unstaged_files_warning(unstaged_files)
+      puts "\nWarning: The following files are not staged in git:"
+      puts unstaged_files
+      puts "\nThese files are #{options[:include_unstaged] ? "included" : "not included"} in the wrap."
+      puts "Use --include-unstaged option to include these files." unless options[:include_unstaged]
+    end
+
     def default_output_file(first_pattern)
       first_item = Dir.glob(first_pattern).first
       if first_item

data/lib/poepod/file_processor.rb

@@ -1,79 +1,37 @@
+# lib/poepod/file_processor.rb
 # frozen_string_literal: true
 
 require_relative "processor"
-require "yaml"
-require "tqdm"
-require "pathname"
-require "open3"
-require "base64"
-require "mime/types"
 
 module Poepod
+  # Processes files for concatenation, handling binary and dot files
   class FileProcessor < Processor
-    EXCLUDE_DEFAULT = [
-      %r{node_modules/}, %r{.git/}, /.gitignore$/, /.DS_Store$/
-    ].freeze
-
-    def initialize(files, output_file, config_file = nil, include_binary = false)
-      super(config_file)
-      @files = files
+    def initialize(
+      patterns,
+      output_file,
+      config_file: nil,
+      include_binary: false,
+      include_dot_files: false,
+      exclude: nil,
+      base_dir: nil
+    )
+      super(
+        config_file,
+        include_binary: include_binary,
+        include_dot_files: include_dot_files,
+        exclude: exclude,
+        base_dir: base_dir,
+      )
+      @patterns = patterns
       @output_file = output_file
-      @failed_files = []
-      @include_binary = include_binary
-    end
-
-    def process
-      total_files = 0
-      copied_files = 0
-
-      File.open(@output_file, "w", encoding: "utf-8") do |output|
-        @files.each do |file|
-          Dir.glob(file).each do |matched_file|
-            next unless File.file?(matched_file)
-
-            total_files += 1
-            file_path, content, error = process_file(matched_file)
-            if content
-              output.puts "--- START FILE: #{file_path} ---"
-              output.puts content
-              output.puts "--- END FILE: #{file_path} ---"
-              copied_files += 1
-            elsif error
-              output.puts "#{file_path}\n#{error}"
-            end
-          end
-        end
-      end
-
-      [total_files, copied_files]
     end
 
     private
 
-    def process_file(file_path)
-      if text_file?(file_path)
-        content = File.read(file_path, encoding: "utf-8")
-        [file_path, content, nil]
-      elsif @include_binary
-        content = encode_binary_file(file_path)
-        [file_path, content, nil]
-      else
-        [file_path, nil, "Skipped binary file"]
+    def collect_files_to_process
+      @patterns.flatten.each_with_object([]) do |pattern, files_to_process|
+        files_to_process.concat(collect_files_from_pattern(pattern))
       end
-    rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
-      @failed_files << file_path
-      [file_path, nil, "Failed to decode the file, as it is not saved with UTF-8 encoding."]
-    end
-
-    def text_file?(file_path)
-      stdout, status = Open3.capture2("file", "-b", "--mime-type", file_path)
-      status.success? && stdout.strip.start_with?("text/")
-    end
-
-    def encode_binary_file(file_path)
-      mime_type = MIME::Types.type_for(file_path).first.content_type
-      encoded_content = Base64.strict_encode64(File.binread(file_path))
-      "Content-Type: #{mime_type}\nContent-Transfer-Encoding: base64\n\n#{encoded_content}"
     end
   end
 end

data/lib/poepod/gem_processor.rb

@@ -1,66 +1,80 @@
 # frozen_string_literal: true
 
-# lib/poepod/gem_processor.rb
 require_relative "processor"
 require "rubygems/specification"
 require "git"
 
 module Poepod
+  # Processes gem files for wrapping, handling unstaged files
   class GemProcessor < Processor
-    def initialize(gemspec_path, config_file = nil, include_unstaged = false)
-      super(config_file)
+    def initialize(
+      gemspec_path,
+      include_unstaged: false,
+      exclude: nil,
+      include_binary: false,
+      include_dot_files: false,
+      base_dir: nil,
+      config_file: nil
+    )
+      super(
+        config_file,
+        include_binary: include_binary,
+        include_dot_files: include_dot_files,
+        exclude: exclude,
+        base_dir: base_dir || File.dirname(gemspec_path),
+      )
       @gemspec_path = gemspec_path
       @include_unstaged = include_unstaged
     end
 
-    def process
-      unless File.exist?(@gemspec_path)
-        return [false, "Error: The specified gemspec file '#{@gemspec_path}' does not exist."]
-      end
+    def process(output_file)
+      return error_no_gemspec unless File.exist?(@gemspec_path)
 
-      begin
-        spec = Gem::Specification.load(@gemspec_path)
-      rescue StandardError => e
-        return [false, "Error loading gemspec: #{e.message}"]
-      end
+      spec = load_gemspec
+      return spec unless spec.is_a?(Gem::Specification)
 
-      gem_name = spec.name
-      output_file = "#{gem_name}_wrapped.txt"
       unstaged_files = check_unstaged_files
 
-      File.open(output_file, "w") do |file|
-        file.puts "# Wrapped Gem: #{gem_name}"
-        file.puts "## Gemspec: #{File.basename(@gemspec_path)}"
+      total_files, copied_files = super(output_file)
 
-        if unstaged_files.any?
-          file.puts "\n## Warning: Unstaged Files"
-          file.puts unstaged_files.join("\n")
-          file.puts "\nThese files are not included in the wrap unless --include-unstaged option is used."
-        end
-
-        file.puts "\n## Files:\n"
+      [true, output_file, unstaged_files]
+    end
 
-        files_to_include = (spec.files + spec.test_files + find_readme_files).uniq
-        files_to_include += unstaged_files if @include_unstaged
+    private
 
-        files_to_include.uniq.each do |relative_path|
-          full_path = File.join(File.dirname(@gemspec_path), relative_path)
-          next unless File.file?(full_path)
+    def collect_files_to_process
+      files_to_include = find_gemspec_files
+      files_to_include += check_unstaged_files if @include_unstaged
 
-          file.puts "--- START FILE: #{relative_path} ---"
-          file.puts File.read(full_path)
-          file.puts "--- END FILE: #{relative_path} ---\n\n"
-        end
+      files_to_include.sort.uniq.reject do |relative_path|
+        should_exclude?(File.join(@base_dir, relative_path))
+      end.map do |relative_path|
+        File.join(@base_dir, relative_path)
       end
+    end
 
-      [true, output_file, unstaged_files]
+    def find_gemspec_files
+      spec = load_gemspec
+      executables = spec.bindir ? collect_files_from_pattern(File.join(@base_dir, spec.bindir, "*")) : []
+
+      (spec.files + spec.test_files + find_readme_files + executables).uniq
     end
 
-    private
+    def error_no_gemspec
+      [false, "Error: The specified gemspec file '#{@gemspec_path}' does not exist."]
+    end
+
+    def load_gemspec
+      Gem::Specification.load(@gemspec_path)
+    rescue StandardError => e
+      [false, "Error loading gemspec: #{e.message}"]
+    end
 
     def find_readme_files
-      Dir.glob(File.join(File.dirname(@gemspec_path), "README*"))
-         .map { |path| Pathname.new(path).relative_path_from(Pathname.new(File.dirname(@gemspec_path))).to_s }
+      gemspec_dir = Pathname.new(File.dirname(@gemspec_path))
+      Dir.glob(gemspec_dir.join("README*")).map do |path|
+        Pathname.new(path).relative_path_from(gemspec_dir).to_s
+      end
     end
 
     def check_unstaged_files
@@ -71,7 +85,7 @@ module Poepod
       modified_files = git.status.changed.keys
 
       (untracked_files + modified_files).select do |file|
-        file.start_with?("lib/", "spec/", "test/")
+        file.start_with?("bin/", "exe/", "lib/", "spec/", "test/")
       end
     rescue Git::GitExecuteError => e
       warn "Git error: #{e.message}. Assuming no unstaged files."

data/lib/poepod/processor.rb

@@ -1,22 +1,149 @@
+# lib/poepod/processor.rb
 # frozen_string_literal: true
 
-# lib/poepod/processor.rb
+require "yaml"
+require "base64"
+require "marcel"
+require "stringio"
+
 module Poepod
+  # Base processor class
   class Processor
-    def initialize(config_file = nil)
+    EXCLUDE_DEFAULT = [
+      %r{node_modules/}, %r{.git/}, /.gitignore$/, /.DS_Store$/,
+    ].freeze
+
+    def initialize(
+      config_file = nil,
+      include_binary: false,
+      include_dot_files: false,
+      exclude: nil,
+      base_dir: nil
+    )
       @config = load_config(config_file)
+      @include_binary = include_binary
+      @include_dot_files = include_dot_files
+      @exclude = exclude || EXCLUDE_DEFAULT
+      @base_dir = base_dir
+      @failed_files = []
+    end
+
+    def process(output_file)
+      files_to_process = collect_files_to_process
+      total_files, copied_files = process_files(files_to_process, output_file)
+      [total_files, copied_files]
+    end
+
+    private
+
+    def process_files(files, output_file)
+      total_files = files.size
+      copied_files = 0
+
+      File.open(output_file, "w", encoding: "utf-8") do |output|
+        files.sort.each do |file_path|
+          process_file(output, file_path)
+          copied_files += 1
+        end
+      end
+
+      [total_files, copied_files]
+    end
+
+    def collect_files_to_process
+      raise NotImplementedError, "Subclasses must implement collect_files_to_process"
+    end
+
+    def collect_files_from_pattern(pattern)
+      expanded_pattern = File.expand_path(pattern)
+      if File.directory?(expanded_pattern)
+        expanded_pattern = File.join(expanded_pattern, "**", "*")
+      end
+
+      Dir.glob(expanded_pattern, File::FNM_DOTMATCH).each_with_object([]) do |file_path, acc|
+        next unless File.file?(file_path)
+        next if should_exclude?(file_path)
+
+        acc << file_path
+      end
     end
 
     def load_config(config_file)
-      if config_file && File.exist?(config_file)
-        YAML.load_file(config_file)
+      return {} unless config_file && File.exist?(config_file)
+
+      YAML.load_file(config_file)
+    end
+
+    def binary_file?(file_path)
+      return false unless File.exist?(file_path) && File.file?(file_path)
+
+      File.open(file_path, "rb") do |file|
+        content = file.read(8192) # Read first 8KB for magic byte detection
+        mime_type = Marcel::MimeType.for(
+          content,
+          name: File.basename(file_path),
+          declared_type: "text/plain",
+        )
+
+        !mime_type.start_with?("text/") && mime_type != "application/json"
+      end
+    end
+
+    def process_file(output = nil, file_path)
+      output ||= StringIO.new
+
+      relative_path = if @base_dir
+          Pathname.new(file_path).relative_path_from(@base_dir).to_s
+        else
+          file_path
+        end
+
+      puts "Adding to bundle: #{relative_path}"
+
+      output.puts "--- START FILE: #{relative_path} ---"
+
+      if binary_file?(file_path) && @include_binary
+        output.puts encode_binary_file(file_path)
       else
-        {}
+        output.puts File.read(file_path)
       end
+
+      output.puts "--- END FILE: #{relative_path} ---\n"
+
+      output.string if output.is_a?(StringIO) # Return the string if using StringIO
+    end
+
+    def encode_binary_file(file_path)
+      content = File.binread(file_path)
+      mime_type = Marcel::MimeType.for(content, name: File.basename(file_path))
+      encoded_content = Base64.strict_encode64(content)
+      <<~HERE
+        Content-Type: #{mime_type}
+        Content-Transfer-Encoding: base64
+
+        #{encoded_content}
+      HERE
+    end
+
+    def dot_file?(file_path)
+      File.basename(file_path).start_with?(".")
     end
 
-    def process
-      raise NotImplementedError, "Subclasses must implement the 'process' method"
+    def should_exclude?(file_path)
+      return true if !@include_dot_files && dot_file?(file_path)
+      return true if !@include_binary && binary_file?(file_path)
+
+      exclude_file?(file_path)
+    end
+
+    def exclude_file?(file_path)
+      @exclude.any? do |pattern|
+        if pattern.is_a?(Regexp)
+          file_path.match?(pattern)
+        else
+          File.fnmatch?(pattern, file_path)
+        end
+      end
     end
   end
 end

data/lib/poepod/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Poepod
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 end

data/poepod.gemspec

@@ -18,8 +18,6 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
       f.match(%r{^(test|spec|features)/})
@@ -31,7 +29,7 @@ Gem::Specification.new do |spec|
   spec.test_files = `git ls-files -- spec/*`.split("\n")
 
   spec.add_runtime_dependency "git", "~> 1.11"
-  spec.add_runtime_dependency "mime-types", "~> 3.3"
+  spec.add_runtime_dependency "marcel", "~> 1.0"
   spec.add_runtime_dependency "parallel", "~> 1.20"
   spec.add_runtime_dependency "thor", "~> 1.0"
   spec.add_runtime_dependency "tqdm"

data/spec/poepod/cli_spec.rb

@@ -10,37 +10,61 @@ RSpec.describe Poepod::Cli do
     let(:temp_dir) { Dir.mktmpdir }
     let(:text_file) { File.join(temp_dir, "text_file.txt") }
     let(:binary_file) { File.join(temp_dir, "binary_file.bin") }
+    let(:dot_file) { File.join(temp_dir, ".hidden_file") }
 
     before do
       File.write(text_file, "Hello, World!")
       File.write(binary_file, [0xFF, 0xD8, 0xFF, 0xE0].pack("C*"))
+      File.write(dot_file, "Hidden content")
     end
 
     after do
       FileUtils.remove_entry(temp_dir)
     end
 
-    it "concatenates text files" do
+    it "concatenates text files and excludes binary and dot files by default" do
       output_file = File.join(temp_dir, "output.txt")
-      expect { cli.concat(text_file, output_file: output_file) }.to output(/1 files detected/).to_stdout
+      expect do
+        cli.invoke(:concat, [text_file], { output_file: output_file })
+      end.to output(/1 files detected\.\n.*1 files have been concatenated/).to_stdout
       expect(File.exist?(output_file)).to be true
-      expect(File.read(output_file)).to include("Hello, World!")
+      content = File.read(output_file)
+      expect(content).to include("Hello, World!")
+      expect(content).not_to include("Hidden content")
     end
 
-    it "excludes binary files by default" do
+    it "includes binary files when specified" do
       output_file = File.join(temp_dir, "output.txt")
       expect do
-        cli.concat(text_file, binary_file,
-                   output_file: output_file)
-      end.to output(/-> 2 files detected\.\n=> 1 files have been concatenated into.*\.txt/).to_stdout
+        cli.invoke(:concat, [text_file, binary_file], { output_file: output_file, include_binary: true })
+      end.to output(/2 files detected\.\n.*2 files have been concatenated/).to_stdout
+      expect(File.exist?(output_file)).to be true
+      content = File.read(output_file)
+      expect(content).to include("Hello, World!")
+      expect(content).to include("Content-Type: image/jpeg")
     end
 
-    it "includes binary files when specified" do
+    it "includes dot files when specified" do
+      output_file = File.join(temp_dir, "output.txt")
+      expect do
+        cli.invoke(:concat, [text_file, dot_file], { output_file: output_file, include_dot_files: true })
+      end.to output(/2 files detected\.\n.*2 files have been concatenated/).to_stdout
+      expect(File.exist?(output_file)).to be true
+      content = File.read(output_file)
+      expect(content).to include("Hello, World!")
+      expect(content).to include("Hidden content")
+    end
+
+    it "uses the specified base directory for relative paths" do
       output_file = File.join(temp_dir, "output.txt")
       expect do
-        cli.invoke(:concat, [text_file, binary_file], output_file: output_file,
-                                                      include_binary: true)
-      end.to output(/-> 2 files detected\.\n=> 2 files have been concatenated into.*\.txt/).to_stdout
+        cli.invoke(:concat, [text_file], { output_file: output_file, base_dir: temp_dir })
+      end.to output(/1 files detected\.\n.*1 files have been concatenated/).to_stdout
+      expect(File.exist?(output_file)).to be true
+      content = File.read(output_file)
+      expect(content).to include("--- START FILE: text_file.txt ---")
+      expect(content).to include("Hello, World!")
+      expect(content).to include("--- END FILE: text_file.txt ---")
     end
   end
 
@@ -70,12 +94,10 @@ RSpec.describe Poepod::Cli do
     end
 
     it "wraps a gem" do
+      output_file = File.join(temp_dir, "test_gem_wrapped.txt")
       expect { cli.wrap(gemspec_file) }.to output(/The gem has been wrapped into/).to_stdout
-      output_file = File.join(Dir.pwd, "test_gem_wrapped.txt")
       expect(File.exist?(output_file)).to be true
       content = File.read(output_file)
-      expect(content).to include("# Wrapped Gem: test_gem")
-      expect(content).to include("## Gemspec: test_gem.gemspec")
       expect(content).to include("--- START FILE: lib/test_gem.rb ---")
       expect(content).to include("puts 'Hello from test_gem'")
       expect(content).to include("--- END FILE: lib/test_gem.rb ---")
@@ -86,5 +108,18 @@ RSpec.describe Poepod::Cli do
         cli.wrap("non_existent.gemspec")
       end.to output(/Error: The specified gemspec file/).to_stdout.and raise_error(SystemExit)
     end
+
+    it "uses the specified base directory for relative paths" do
+      base_dir = File.dirname(gemspec_file)
+      output_file = File.join(base_dir, "test_gem_wrapped.txt")
+      expect do
+        cli.invoke(:wrap, [gemspec_file], { base_dir: base_dir, output_file: output_file })
+      end.to output(/The gem has been wrapped into/).to_stdout
+      expect(File.exist?(output_file)).to be true
+      content = File.read(output_file)
+      expect(content).to include("--- START FILE: lib/test_gem.rb ---")
+      expect(content).to include("puts 'Hello from test_gem'")
+      expect(content).to include("--- END FILE: lib/test_gem.rb ---")
+    end
   end
 end

data/spec/poepod/file_processor_spec.rb

@@ -11,11 +11,13 @@ RSpec.describe Poepod::FileProcessor do
   let(:text_file1) { File.join(temp_dir, "file1.txt") }
   let(:text_file2) { File.join(temp_dir, "file2.txt") }
   let(:binary_file) { File.join(temp_dir, "binary_file.bin") }
+  let(:dot_file) { File.join(temp_dir, ".hidden_file") }
 
   before do
     File.write(text_file1, "Content of file1.\n")
     File.write(text_file2, "Content of file2.\n")
     File.write(binary_file, [0xFF, 0xD8, 0xFF, 0xE0].pack("C*"))
+    File.write(dot_file, "Content of hidden file.\n")
   end
 
   after do
@@ -23,41 +25,126 @@ RSpec.describe Poepod::FileProcessor do
     output_file.unlink
   end
 
-  let(:processor) { described_class.new([text_file1, text_file2], output_file.path) }
-
   describe "#process" do
-    it "processes text files and writes them to the output file" do
-      total_files, copied_files = processor.process
-      expect(total_files).to eq(2)
-      expect(copied_files).to eq(2)
-
-      output_content = File.read(output_file.path, encoding: "utf-8")
-      expected_content = <<~TEXT
-        --- START FILE: #{text_file1} ---
-        Content of file1.
-        --- END FILE: #{text_file1} ---
-        --- START FILE: #{text_file2} ---
-        Content of file2.
-        --- END FILE: #{text_file2} ---
-      TEXT
-      expect(output_content).to eq(expected_content)
+    context "with default options" do
+      let(:processor) { described_class.new([text_file1, text_file2], output_file.path) }
+
+      it "processes text files and excludes binary and dot files" do
+        total_files, copied_files = processor.process(output_file.path)
+        expect(total_files).to eq(2)
+        expect(copied_files).to eq(2)
+
+        output_content = File.read(output_file.path, encoding: "utf-8")
+        expected_content = <<~TEXT
+          --- START FILE: #{text_file1} ---
+          Content of file1.
+          --- END FILE: #{text_file1} ---
+          --- START FILE: #{text_file2} ---
+          Content of file2.
+          --- END FILE: #{text_file2} ---
+        TEXT
+        expect(output_content).to eq(expected_content)
+      end
+    end
+
+    context "with include_binary option" do
+      let(:processor) { described_class.new([File.join(temp_dir, "*")], output_file.path, include_binary: true) }
+
+      it "includes binary files" do
+        total_files, copied_files = processor.process(output_file.path)
+        expect(total_files).to eq(3)
+        expect(copied_files).to eq(3)
+
+        output_content = File.read(output_file.path, encoding: "utf-8")
+        expected_content = <<~TEXT
+          --- START FILE: #{binary_file} ---
+          Content-Type: image/jpeg
+          Content-Transfer-Encoding: base64
+
+          /9j/4A==
+          --- END FILE: #{binary_file} ---
+          --- START FILE: #{text_file1} ---
+          Content of file1.
+          --- END FILE: #{text_file1} ---
+          --- START FILE: #{text_file2} ---
+          Content of file2.
+          --- END FILE: #{text_file2} ---
+        TEXT
+        expect(output_content).to eq(expected_content)
+      end
+    end
+
+    context "with include_dot_files option" do
+      let(:processor) { described_class.new([File.join(temp_dir, "*")], output_file.path, include_dot_files: true) }
+
+      it "includes dot files" do
+        total_files, copied_files = processor.process(output_file.path)
+        expect(total_files).to eq(3)
+        expect(copied_files).to eq(3)
+
+        output_content = File.read(output_file.path, encoding: "utf-8")
+        expected_content = <<~TEXT
+          --- START FILE: #{dot_file} ---
+          Content of hidden file.
+          --- END FILE: #{dot_file} ---
+          --- START FILE: #{text_file1} ---
+          Content of file1.
+          --- END FILE: #{text_file1} ---
+          --- START FILE: #{text_file2} ---
+          Content of file2.
+          --- END FILE: #{text_file2} ---
+        TEXT
+        expect(output_content).to eq(expected_content)
+      end
+    end
+
+    context "with both include_binary and include_dot_files options" do
+      let(:processor) do
+        described_class.new([File.join(temp_dir, "*")], output_file.path, include_binary: true, include_dot_files: true)
+      end
+
+      it "includes all files in sorted order" do
+        total_files, copied_files = processor.process(output_file.path)
+        expect(total_files).to eq(4)
+        expect(copied_files).to eq(4)
+
+        output_content = File.read(output_file.path, encoding: "utf-8")
+        expected_content = <<~HERE
+          --- START FILE: #{dot_file} ---
+          Content of hidden file.
+          --- END FILE: #{dot_file} ---
+          --- START FILE: #{binary_file} ---
+          Content-Type: image/jpeg
+          Content-Transfer-Encoding: base64
+
+          /9j/4A==
+          --- END FILE: #{binary_file} ---
+          --- START FILE: #{text_file1} ---
+          Content of file1.
+          --- END FILE: #{text_file1} ---
+          --- START FILE: #{text_file2} ---
+          Content of file2.
+          --- END FILE: #{text_file2} ---
+        HERE
+
+        expect(output_content).to eq(expected_content)
+      end
     end
   end
 
   describe "#process_file" do
+    let(:processor) { described_class.new([text_file1], output_file.path) }
+
     it "reads the content of a file" do
-      file_path, content, error = processor.send(:process_file, text_file1)
-      expect(file_path).to eq(text_file1)
-      expect(content).to eq("Content of file1.\n")
-      expect(error).to be_nil
+      content = processor.send(:process_file, nil, text_file1)
+      expect(content).to include("Content of file1.\n")
     end
 
     it "handles encoding errors gracefully" do
       allow(File).to receive(:read).and_raise(Encoding::InvalidByteSequenceError)
-      file_path, content, error = processor.send(:process_file, text_file1)
-      expect(file_path).to eq(text_file1)
-      expect(content).to be_nil
-      expect(error).to eq("Failed to decode the file, as it is not saved with UTF-8 encoding.")
+      expect do
+        processor.send(:process_file, nil, text_file1)
+      end.to raise_error(Encoding::InvalidByteSequenceError)
     end
   end
 end

data/spec/poepod/gem_processor_spec.rb

@@ -34,67 +34,78 @@ RSpec.describe Poepod::GemProcessor do
 
   describe "#process" do
     let(:processor) { described_class.new(gemspec_file) }
+    let(:output_file) { File.join(temp_dir, "test_gem_wrapped.txt") }
 
     before do
       # Mock Git operations
       allow(Git).to receive(:open).and_return(double(status: double(untracked: {}, changed: {})))
     end
 
-    it "processes the gem files, includes README files, and spec files" do
-      success, output_file = processor.process
+    it "processes the gem files, includes README files, and spec files in sorted order" do
+      success, result, _ = processor.process(output_file)
       expect(success).to be true
       expect(File.exist?(output_file)).to be true
 
       content = File.read(output_file)
-      expect(content).to include("# Wrapped Gem: test_gem")
-      expect(content).to include("## Gemspec: test_gem.gemspec")
-      expect(content).to include("--- START FILE: lib/test_gem.rb ---")
-      expect(content).to include("puts 'Hello from test_gem'")
-      expect(content).to include("--- END FILE: lib/test_gem.rb ---")
-      expect(content).to include("--- START FILE: spec/test_gem_spec.rb ---")
-      expect(content).to include("RSpec.describe TestGem do")
-      expect(content).to include("--- END FILE: spec/test_gem_spec.rb ---")
-      expect(content).to include("--- START FILE: README.md ---")
-      expect(content).to include("# Test Gem\n\nThis is a test gem.")
-      expect(content).to include("--- END FILE: README.md ---")
-      expect(content).to include("--- START FILE: README.txt ---")
-      expect(content).to include("Test Gem\n\nThis is a test gem in plain text.")
-      expect(content).to include("--- END FILE: README.txt ---")
+
+      file_order = content.scan(/--- START FILE: (.+) ---/).flatten
+      expected_order = [
+        "README.md",
+        "README.txt",
+        "lib/test_gem.rb",
+        "spec/test_gem_spec.rb",
+      ]
+      expect(file_order).to eq(expected_order)
+
+      expected = <<~HERE
+        --- START FILE: README.md ---
+        # Test Gem
+
+        This is a test gem.
+        --- END FILE: README.md ---
+        --- START FILE: README.txt ---
+        Test Gem
+
+        This is a test gem in plain text.
+        --- END FILE: README.txt ---
+        --- START FILE: lib/test_gem.rb ---
+        puts 'Hello from test_gem'
+        --- END FILE: lib/test_gem.rb ---
+        --- START FILE: spec/test_gem_spec.rb ---
+        RSpec.describe TestGem do
+        end
+        --- END FILE: spec/test_gem_spec.rb ---
+      HERE
+      expect(content).to eq(expected)
     end
 
     context "with non-existent gemspec" do
       let(:processor) { described_class.new("non_existent.gemspec") }
 
       it "returns an error" do
-        success, error_message = processor.process
+        success, error_message, _ = processor.process(output_file)
         expect(success).to be false
         expect(error_message).to include("Error: The specified gemspec file")
       end
     end
 
     context "with unstaged files" do
+      let(:processor) { described_class.new(gemspec_file, include_unstaged: false) }
       let(:mock_git) { instance_double(Git::Base) }
       let(:mock_status) { instance_double(Git::Status) }
 
       before do
         allow(Git).to receive(:open).and_return(mock_git)
         allow(mock_git).to receive(:status).and_return(mock_status)
-        allow(mock_status).to receive(:untracked).and_return({ "lib/unstaged_file.rb" => "??" })
+        allow(mock_status).to receive(:untracked).and_return(
+          { "lib/unstaged_file.rb" => "??" }
+        )
         allow(mock_status).to receive(:changed).and_return({})
       end
 
-      it "warns about unstaged files" do
-        success, output_file, unstaged_files = processor.process
-        expect(success).to be true
-        expect(unstaged_files).to eq(["lib/unstaged_file.rb"])
-
-        content = File.read(output_file)
-        expect(content).to include("## Warning: Unstaged Files")
-        expect(content).to include("lib/unstaged_file.rb")
-      end
-
       context "with include_unstaged option" do
-        let(:processor) { described_class.new(gemspec_file, nil, true) }
+        let(:processor) { described_class.new(gemspec_file, include_unstaged: true) }
+        let(:output_file) { File.join(temp_dir, "test_gem_wrapped.txt") }
 
         it "includes unstaged files" do
           allow(File).to receive(:file?).and_return(true)
@@ -105,7 +116,7 @@ RSpec.describe Poepod::GemProcessor do
             "spec/test_gem_spec.rb" => "RSpec.describe TestGem do\nend",
             "README.md" => "# Test Gem\n\nThis is a test gem.",
             "README.txt" => "Test Gem\n\nThis is a test gem in plain text.",
-            "lib/unstaged_file.rb" => "Unstaged content"
+            "lib/unstaged_file.rb" => "Unstaged content",
           }
 
           # Mock File.read
@@ -115,42 +126,46 @@ RSpec.describe Poepod::GemProcessor do
               file_contents[file_name]
             elsif path.end_with?("_wrapped.txt")
               # This is the output file, so we'll construct its content here
-              wrapped_content = "# Wrapped Gem: test_gem\n"
-              wrapped_content += "## Gemspec: test_gem.gemspec\n\n"
-              wrapped_content += "## Warning: Unstaged Files\n"
-              wrapped_content += "lib/unstaged_file.rb\n\n"
-              wrapped_content += "## Files:\n\n"
-              file_contents.each do |file, content|
-                wrapped_content += "--- START FILE: #{file} ---\n"
-                wrapped_content += "#{content}\n"
-                wrapped_content += "--- END FILE: #{file} ---\n\n"
-              end
-              wrapped_content
+              file_contents.map do |file, content|
+                <<~HERE
+                  --- START FILE: #{file} ---
+                  #{content}
+                  --- END FILE: #{file} ---
+                HERE
+              end.join("")
             else
               "Default content for #{path}"
             end
           end
 
-          success, output_file, unstaged_files = processor.process
+          success, result, unstaged_files = processor.process(output_file)
           expect(success).to be true
           expect(unstaged_files).to eq(["lib/unstaged_file.rb"])
 
           content = File.read(output_file)
-          expect(content).to include("--- START FILE: lib/test_gem.rb ---")
-          expect(content).to include("puts 'Hello from test_gem'")
-          expect(content).to include("--- END FILE: lib/test_gem.rb ---")
-          expect(content).to include("--- START FILE: spec/test_gem_spec.rb ---")
-          expect(content).to include("RSpec.describe TestGem do")
-          expect(content).to include("--- END FILE: spec/test_gem_spec.rb ---")
-          expect(content).to include("--- START FILE: README.md ---")
-          expect(content).to include("# Test Gem\n\nThis is a test gem.")
-          expect(content).to include("--- END FILE: README.md ---")
-          expect(content).to include("--- START FILE: README.txt ---")
-          expect(content).to include("Test Gem\n\nThis is a test gem in plain text.")
-          expect(content).to include("--- END FILE: README.txt ---")
-          expect(content).to include("--- START FILE: lib/unstaged_file.rb ---")
-          expect(content).to include("Unstaged content")
-          expect(content).to include("--- END FILE: lib/unstaged_file.rb ---")
+          expected = <<~HERE
+            --- START FILE: lib/test_gem.rb ---
+            puts 'Hello from test_gem'
+            --- END FILE: lib/test_gem.rb ---
+            --- START FILE: spec/test_gem_spec.rb ---
+            RSpec.describe TestGem do
+            end
+            --- END FILE: spec/test_gem_spec.rb ---
+            --- START FILE: README.md ---
+            # Test Gem
+
+            This is a test gem.
+            --- END FILE: README.md ---
+            --- START FILE: README.txt ---
+            Test Gem
+
+            This is a test gem in plain text.
+            --- END FILE: README.txt ---
+            --- START FILE: lib/unstaged_file.rb ---
+            Unstaged content
+            --- END FILE: lib/unstaged_file.rb ---
+          HERE
+          expect(content).to eq(expected)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: poepod
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-22 00:00:00.000000000 Z
+date: 2024-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.11'
 - !ruby/object:Gem::Dependency
-  name: mime-types
+  name: marcel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement