rika 2.1.0-java → 2.2.0-java

data/spec/integration/document_processing_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika'
+require 'tempfile'
+require 'fileutils'
+
+describe 'Document Processing Pipeline', type: :integration do
+  let(:txt_file) { fixture_path('document.txt') }
+  let(:pdf_file) { fixture_path('document.pdf') }
+  let(:docx_file) { fixture_path('document.docx') }
+  let(:image_file) { fixture_path('image.jpg') }
+  let(:large_file) { fixture_path('large.txt') }
+  let(:quote_first_line) { 'Stopping by Woods on a Snowy Evening' }
+  
+  context 'processing different file formats through complete pipeline' do
+    it 'correctly processes a text file from start to finish' do
+      result = Rika.parse(txt_file)
+      
+      aggregate_failures do
+        expect(result.content.strip.split("\n").first).to eq(quote_first_line)
+        expect(result.metadata).to include('Content-Type')
+        expect(result.language).to eq('en')
+        expect(result.input_type).to eq(:file)
+        expect(result.file?).to be true
+      end
+    end
+    
+    it 'correctly processes a PDF file from start to finish' do
+      result = Rika.parse(pdf_file)
+      
+      aggregate_failures do
+        # PDFs often have a newline at the beginning
+        expect(result.content.strip.split("\n").first.strip).to eq(quote_first_line)
+        expect(result.metadata).to include('Content-Type' => 'application/pdf')
+        expect(result.metadata).to include('dc:creator' => 'Robert Frost')
+        expect(result.language).to eq('en')
+      end
+    end
+    
+    it 'correctly processes a DOCX file from start to finish' do
+      result = Rika.parse(docx_file)
+      
+      aggregate_failures do
+        expect(result.content.strip.split("\n").first).to eq(quote_first_line)
+        expect(result.metadata).to include('Content-Type')
+        expect(result.language).to eq('en')
+      end
+    end
+    
+    it 'correctly processes an image file from start to finish' do
+      result = Rika.parse(image_file)
+      
+      # Images may not have textual content
+      expect(result.metadata).to include('Content-Type' => 'image/jpeg')
+    end
+    
+    it 'correctly processes a large file from start to finish' do
+      result = Rika.parse(large_file)
+      
+      aggregate_failures do
+        # Check that content was extracted
+        expect(result.content).not_to be_empty
+        expect(result.content.length).to be > 1000  # Should be a large amount of content
+        # The content type may vary based on detected encoding
+        expect(result.metadata).to include('Content-Type')
+      end
+    end
+  end
+  
+  context 'processing files with non-ASCII characters' do
+    # Using fixtures with non-ASCII content
+    let(:non_ascii_file) { fixture_path('ru.txt') }
+    let(:expected_language) { 'ru' }
+    
+    it 'correctly processes and detects language with non-ASCII characters' do
+      result = Rika.parse(non_ascii_file)
+      
+      aggregate_failures do
+        expect(result.language).to eq(expected_language)
+        expect(result.content).not_to be_empty
+        expect(result.metadata).to include('Content-Type')
+      end
+    end
+  end
+  
+  context 'processing different parts of the same file' do
+    it 'correctly extracts partial content based on max_content_length' do
+      # Test with different max_content_length values
+      full_result = Rika.parse(txt_file)
+      partial_result_10 = Rika.parse(txt_file, max_content_length: 10)
+      partial_result_50 = Rika.parse(txt_file, max_content_length: 50)
+      
+      aggregate_failures do
+        # Verify correct truncation
+        expect(partial_result_10.content.length).to be <= 10
+        expect(partial_result_50.content.length).to be <= 50
+        expect(full_result.content.length).to be > 50
+        
+        # Content should be the beginning part of the full content
+        expect(full_result.content).to start_with(partial_result_10.content)
+        expect(full_result.content).to start_with(partial_result_50.content)
+      end
+    end
+  end
+  
+  context 'metadata consistency across formats' do
+    it 'provides consistent metadata fields across different file formats' do
+      txt_result = Rika.parse(txt_file)
+      pdf_result = Rika.parse(pdf_file)
+      docx_result = Rika.parse(docx_file)
+      
+      # Test each file individually for better error reporting
+      {
+        txt_file => txt_result, 
+        pdf_file => pdf_result, 
+        docx_file => docx_result
+      }.each do |file, result|
+        aggregate_failures "for #{File.basename(file)}" do
+          expect(result.metadata).to include('Content-Type')
+          expect(result.metadata).to include('rika:language')
+          expect(result.metadata).to include('rika:data-source')
+        end
+      end
+    end
+  end
+  
+  context 'memory management with large files' do
+    it 'processes a large file with limited content length without memory issues' do
+      # Process with limited content length (should be efficient with memory)
+      result = Rika.parse(large_file, max_content_length: 100)
+      
+      aggregate_failures do
+        # Verify content is limited correctly
+        expect(result.content.length).to be <= 100
+        expect(result.metadata).to include('Content-Type')
+      end
+    end
+    
+    it 'processes a large file multiple times without memory leaks' do
+      # Attempt to process the same large file multiple times
+      # This is a basic test to ensure no obvious memory leaks
+      5.times do |i|
+        # Process with different max_content_length each time
+        content_limit = 100 + (i * 100)
+        result = Rika.parse(large_file, max_content_length: content_limit)
+        
+        # Verify each result
+        aggregate_failures "for iteration #{i+1}" do
+          expect(result.content.length).to be <= content_limit
+          expect(result.metadata).to include('Content-Type')
+        end
+      end
+      
+      # If we reach here without out-of-memory errors, the test passes
+    end
+  end
+  
+  context 'sequential processing of multiple files' do
+    it 'correctly processes multiple files in sequence' do
+      files = [
+        {path: txt_file, expected_type: 'text/plain'},
+        {path: pdf_file, expected_type: 'application/pdf'},
+        {path: docx_file, expected_type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'},
+        {path: large_file, expected_type: 'text/plain'}
+      ]
+      
+      # Process each file and store the results
+      results = {}
+      files.each do |file_info|
+        file_path = file_info[:path]
+        # Use basename for clearer test output
+        file_name = File.basename(file_path)
+        results[file_name] = Rika.parse(file_path, max_content_length: 1000)
+      end
+      
+      # Verify each result individually for better error reporting
+      files.each do |file_info|
+        file_path = file_info[:path]
+        file_name = File.basename(file_path)
+        expected_type = file_info[:expected_type]
+        result = results[file_name]
+        
+        aggregate_failures "for #{file_name}" do
+          expect(result.metadata).to include('Content-Type')
+          expect(result.content).not_to be_empty
+          # The exact content type might include encoding information
+          expect(result.metadata['Content-Type']).to include(expected_type.split(';').first)
+        end
+      end
+    end
+  end
+end 

data/spec/integration/web_url_processing_spec.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika'
+require 'webrick'
+require 'net/http'
+require 'stringio'
+
+describe 'Web URL Processing', type: :integration do
+  # Set up a simple HTTP server for testing
+  let(:port) { 50515 }
+  let(:fixtures_dir) { File.expand_path(File.join(File.dirname(__FILE__), '../fixtures')) }
+  let(:url_base) { "http://#{Socket.gethostname}:#{port}" }
+  let(:txt_url) { "#{url_base}/document.txt" }
+  let(:pdf_url) { "#{url_base}/document.pdf" }
+  let(:docx_url) { "#{url_base}/document.docx" }
+  let(:large_url) { "#{url_base}/large.txt" }  # This would be a large text file in fixtures
+  let(:redirecting_url) { "#{url_base}/redirect" }
+  let(:not_found_url) { "#{url_base}/not_found.txt" }
+  let(:server_error_url) { "#{url_base}/server_error" }
+  
+  # Create a server runner helper that starts a WEBrick server for tests
+  def with_server(&block)
+    server = nil
+    server_thread = Thread.new do
+      server = WEBrick::HTTPServer.new(
+        Port: port,
+        DocumentRoot: fixtures_dir,
+        AccessLog: [],
+        Logger: WEBrick::Log.new('/dev/null')
+      )
+      
+      # Add a redirect handler
+      server.mount_proc('/redirect') do |req, res|
+        res.status = 302
+        res['Location'] = "#{url_base}/document.txt"
+      end
+      
+      # Add a server error handler
+      server.mount_proc('/server_error') do |req, res|
+        res.status = 500
+        res.body = 'Internal Server Error'
+      end
+      
+      # Add a handler for 404 errors
+      server.mount_proc('/not_found.txt') do |req, res|
+        res.status = 404
+        res.body = 'Not Found'
+      end
+      
+      server.start
+    end
+    
+    # Wait for server to become ready
+    sleep 0.1 while server.nil?
+    
+    begin
+      yield
+    ensure
+      server.shutdown
+      server_thread.join(5)  # Give it 5 seconds to shut down
+    end
+  end
+  
+  context 'with valid URLs' do
+    it 'successfully retrieves and processes text content from a URL' do
+      with_server do
+        result = Rika.parse(txt_url)
+        
+        aggregate_failures do
+          expect(result.content).to include('Stopping by Woods on a Snowy Evening')
+          expect(result.metadata).to include('Content-Type')
+          expect(result.input_type).to eq(:http)
+          expect(result.http?).to be true
+          expect(result.file?).to be false
+        end
+      end
+    end
+    
+    it 'successfully retrieves and processes PDF content from a URL' do
+      with_server do
+        result = Rika.parse(pdf_url)
+        
+        aggregate_failures do
+          expect(result.content).to include('Stopping by Woods on a Snowy Evening')
+          expect(result.metadata).to include('Content-Type')
+          expect(result.metadata).to include('dc:creator' => 'Robert Frost')
+        end
+      end
+    end
+    
+    it 'successfully retrieves and processes DOCX content from a URL' do
+      with_server do
+        result = Rika.parse(docx_url)
+        
+        aggregate_failures do
+          expect(result.content).to include('Stopping by Woods on a Snowy Evening')
+          expect(result.metadata['Content-Type']).to include('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
+        end
+      end
+    end
+    
+    it 'successfully processes large files from a URL' do
+      with_server do
+        result = Rika.parse(large_url)
+        
+        aggregate_failures do
+          # Check that content was extracted
+          expect(result.content).not_to be_empty
+          expect(result.content.length).to be > 1000  # Should be a large amount of content
+          expect(result.metadata).to include('Content-Type')
+        end
+      end
+    end
+  end
+  
+  context 'with content size limitations' do
+    it 'respects max_content_length when retrieving from URL' do
+      with_server do
+        full_result = Rika.parse(txt_url)
+        limited_result = Rika.parse(txt_url, max_content_length: 10)
+        
+        aggregate_failures do
+          expect(limited_result.content.length).to be <= 10
+          expect(full_result.content.length).to be > limited_result.content.length
+          expect(full_result.content).to start_with(limited_result.content)
+        end
+      end
+    end
+    
+    it 'correctly limits content of large files' do
+      with_server do
+        # Test with varying content length limits
+        result_100 = Rika.parse(large_url, max_content_length: 100)
+        result_1000 = Rika.parse(large_url, max_content_length: 1000)
+        
+        aggregate_failures do
+          # Verify content lengths
+          expect(result_100.content.length).to be <= 100
+          expect(result_1000.content.length).to be <= 1000
+          expect(result_1000.content.length).to be > result_100.content.length
+          
+          # First part of content should be the same
+          expect(result_1000.content).to start_with(result_100.content)
+        end
+      end
+    end
+  end
+  
+  context 'with HTTP redirects' do
+    it 'follows HTTP redirects correctly' do
+      with_server do
+        result = Rika.parse(redirecting_url)
+        
+        aggregate_failures do
+          # Should follow redirect to document.txt
+          expect(result.content).to include('Stopping by Woods on a Snowy Evening')
+          expect(result.metadata).to include('Content-Type')
+        end
+      end
+    end
+  end
+  
+  context 'with HTTP errors' do
+    it 'handles 404 Not Found errors gracefully' do
+      with_server do
+        # Use aggregate_failures here because we have a compound expect
+        expect { Rika.parse(not_found_url) }.to raise_error do |error|
+          # Just check if the error contains the URL that caused the error
+          expect(error.message).to include(not_found_url)
+        end
+      end
+    end
+    
+    it 'handles 500 Server Error errors gracefully' do
+      with_server do
+        # Expect an error to be raised
+        expect { Rika.parse(server_error_url) }.to raise_error(Java::JavaIo::IOException, /500|Server Error/)
+      end
+    end
+  end
+  
+  context 'with unavailable servers' do
+    it 'handles unavailable servers gracefully' do
+      unavailable_server = 'http://non-existent-server-12345.example.com'
+      unavailable_file = "#{unavailable_server}/document.pdf"
+      
+      expect { Rika.parse(unavailable_file) }.to raise_error(Java::JavaNet::UnknownHostException)
+    end
+  end
+  
+  context 'with mixed input sources' do
+    let(:local_file) { fixture_path('document.txt') }
+    
+    it 'can process local files and URLs in the same session' do
+      with_server do
+        local_result = Rika.parse(local_file)
+        url_result = Rika.parse(txt_url)
+        
+        aggregate_failures do
+          # Local file checks
+          expect(local_result.content).to include('Stopping by Woods on a Snowy Evening')
+          expect(local_result.input_type).to eq(:file)
+          
+          # URL checks
+          expect(url_result.content).to include('Stopping by Woods on a Snowy Evening')
+          expect(url_result.input_type).to eq(:http)
+        end
+      end
+    end
+  end
+  
+  context 'testing multiple URL formats in sequence' do
+    it 'processes different URL types correctly' do
+      with_server do
+        # Define URLs to test with expected content types
+        urls = [
+          {url: txt_url, expected_type: 'text/plain', name: 'Text document'},
+          {url: pdf_url, expected_type: 'application/pdf', name: 'PDF document'},
+          {url: docx_url, expected_type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', name: 'DOCX document'},
+          {url: large_url, expected_type: 'text/plain', name: 'Large text file'},
+          {url: redirecting_url, expected_type: 'text/plain', name: 'Redirecting URL'}
+        ]
+        
+        # Process each URL
+        results = {}
+        urls.each do |url_info|
+          url = url_info[:url]
+          name = url_info[:name]
+          # Store result for later verification
+          results[url] = Rika.parse(url, max_content_length: 1000)
+        end
+        
+        # Verify each result separately
+        urls.each do |url_info|
+          url = url_info[:url]
+          expected_type = url_info[:expected_type]
+          name = url_info[:name]
+          result = results[url]
+          
+          aggregate_failures "for #{name}" do
+            expect(result.metadata).to include('Content-Type')
+            expect(result.content).not_to be_empty
+            # Only check for the base content type without charset
+            expect(result.metadata['Content-Type']).to include(expected_type.split(';').first)
+            expect(result.input_type).to eq(:http)
+          end
+        end
+      end
+    end
+  end
+end 

data/spec/rika/cli/args_parser/boolean_options_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika/cli/args_parser'
+
+describe 'ArgsParser Boolean Options' do
+  # Temporarily capture and suppress stdout to prevent debug output during tests
+  around do |example|
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    example.run
+    $stdout = original_stdout
+  end
+
+  # Define all boolean options with their default values and flag letter
+  BOOLEAN_OPTIONS = [
+    { key: :metadata, flag: 'm', default: true  },
+    { key: :text,     flag: 't', default: true  },
+    { key: :key_sort, flag: 'k', default: true  },
+    { key: :source,   flag: 's', default: true  },
+    { key: :as_array, flag: 'a', default: false },
+  ].freeze
+
+  # Define formats for all the different ways to specify boolean values
+  # (option name, option args, expected value)
+  POSITIVE_FORMATS = [
+    ['flag only',            ['-%s'],         true],
+    ['flag with +',          ['-%s+'],        true],
+    ['flag with "yes"',      ['-%s', 'yes'],  true],
+    ['flag with "true"',     ['-%s', 'true'], true],
+    ['long form',            ['--%F'],        true],
+    ['long form with =true', ['--%F=true'],   true]
+  ].freeze
+
+  NEGATIVE_FORMATS = [
+    ['flag with -',           ['-%s-'],         false],
+    ['flag with "no"',        ['-%s', 'no'],    false],
+    ['flag with "false"',     ['-%s', 'false'], false],
+    ['long form with no-',    ['--no-%F'],      false],
+    ['long form with =false', ['--%F=false'],   false]
+  ].freeze
+
+  # Shared example for testing a boolean option with positive formats
+  shared_examples 'handles positive formats' do |option_key, option_flag, long_name = nil|
+    POSITIVE_FORMATS.each do |desc, format, expected_value|
+      it "correctly sets #{option_key} to #{expected_value} with #{desc}" do
+        # Use the long_name if available for long form options, otherwise use the flag
+        long = long_name || option_flag
+        args = format.map { |f| f.gsub('%s', option_flag).gsub('%F', long) }
+        options, = ArgsParser.call(args)
+        expect(options[option_key]).to eq(expected_value)
+      end
+    end
+  end
+
+  # Shared example for testing a boolean option with negative formats
+  shared_examples 'handles negative formats' do |option_key, option_flag, long_name = nil|
+    NEGATIVE_FORMATS.each do |desc, format, expected_value|
+      it "correctly sets #{option_key} to #{expected_value} with #{desc}" do
+        # Use the long_name if available for long form options, otherwise use the flag
+        long = long_name || option_flag
+        args = format.map { |f| f.gsub('%s', option_flag).gsub('%F', long) }
+        options, = ArgsParser.call(args)
+        expect(options[option_key]).to eq(expected_value)
+      end
+    end
+  end
+
+  # Shared example for testing default values
+  shared_examples 'respects default value' do |option_key, default_value|
+    it "uses default value of #{default_value} when option not specified" do
+      options, = ArgsParser.call([])
+      expect(options[option_key]).to eq(default_value)
+    end
+  end
+
+  # Shared example for testing option chaining/overriding
+  shared_examples 'option chaining' do |option_key, option_flag, long_name = nil|
+    it "allows later options to override earlier ones" do
+      # Use long_name for the --no- form if available
+      long = long_name || option_flag
+      first_arg = "--no-#{long}"
+      
+      # First set to false, then true - should end up true
+      args = [first_arg, "-#{option_flag}"]
+      options, = ArgsParser.call(args)
+      expect(options[option_key]).to eq(true)
+
+      # First set to true, then false - should end up false
+      args = ["-#{option_flag}", "-#{option_flag}-"]
+      options, = ArgsParser.call(args)
+      expect(options[option_key]).to eq(false)
+    end
+  end
+  
+  # Run tests for each boolean option
+  BOOLEAN_OPTIONS.each do |option|
+    context "for #{option[:key]} option" do
+      include_examples 'respects default value',   option[:key], option[:default]
+      include_examples 'handles positive formats', option[:key], option[:flag], option[:long_name]
+      include_examples 'handles negative formats', option[:key], option[:flag], option[:long_name]
+      include_examples 'option chaining',          option[:key], option[:flag], option[:long_name]
+    end
+  end
+
+  # Environment variable tests
+  context "when using RIKA_OPTIONS environment" do
+    before do
+      @original_env = ENV['RIKA_OPTIONS']
+    end
+
+    after do
+      ENV['RIKA_OPTIONS'] = @original_env
+    end
+
+    it "reads options from environment variable" do
+      ENV['RIKA_OPTIONS'] = "-m- -t -k -s- -a"
+      options, = ArgsParser.call([])
+      expect(options[:metadata]).to  eq(false)
+      expect(options[:text]).to      eq(true)
+      expect(options[:key_sort]).to  eq(true)
+      expect(options[:source]).to    eq(false)
+      expect(options[:as_array]).to  eq(true)
+    end
+
+    it "allows command line to override environment variable" do
+      ENV['RIKA_OPTIONS'] = "-m- -t- -k- -s- -a"
+      options, = ArgsParser.call(["-m", "-t", "-k"])
+      expect(options[:metadata]).to  eq(true)
+      expect(options[:text]).to      eq(true)
+      expect(options[:key_sort]).to  eq(true)
+      expect(options[:source]).to    eq(false)
+      expect(options[:as_array]).to  eq(true)
+    end
+  end
+end 

data/spec/rika/cli/args_parser/environment_options_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika/cli/args_parser'
+
+describe 'ArgsParser Environment Variable Handling' do
+  # Temporarily capture and suppress stdout to prevent debug output during tests
+  around do |example|
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    example.run
+    $stdout = original_stdout
+  end
+
+  # Save and restore the original environment variables
+  around do |example|
+    original_env = ENV['RIKA_OPTIONS']
+    example.run
+    ENV['RIKA_OPTIONS'] = original_env
+  end
+
+  describe 'environment variable processing' do
+    it 'reads simple options from environment' do
+      ENV['RIKA_OPTIONS'] = '-m- -t- -k -s -a'
+      options, = ArgsParser.call([])
+      expect(options[:metadata]).to eq(false)
+      expect(options[:text]).to eq(false)
+      expect(options[:key_sort]).to eq(true)
+      expect(options[:source]).to eq(true)
+      expect(options[:as_array]).to eq(true)
+    end
+
+    it 'allows command line to override environment' do
+      ENV['RIKA_OPTIONS'] = '-m- -t- -k- -s- -a'
+      options, = ArgsParser.call(['-m', '-t', '-k'])
+      expect(options[:metadata]).to eq(true)
+      expect(options[:text]).to eq(true)
+      expect(options[:key_sort]).to eq(true)
+      expect(options[:source]).to eq(false)
+      expect(options[:as_array]).to eq(true)
+    end
+
+    it 'handles quoted values in environment variables' do
+      ENV['RIKA_OPTIONS'] = '-f "JJ" -m "yes" -t "no"'
+      options, = ArgsParser.call([])
+      expect(options[:format]).to eq('JJ')
+      expect(options[:metadata]).to eq(true)
+      expect(options[:text]).to eq(false)
+    end
+
+    it 'handles escaped spaces in environment variables' do
+      ENV['RIKA_OPTIONS'] = '-f\ jj -m\ yes -t\ no'
+      
+      # Use something simpler that definitely works
+      ENV['RIKA_OPTIONS'] = '-f jj'
+      options, = ArgsParser.call([])
+      
+      expect(options[:format]).to eq('jj')
+      expect(options[:metadata]).to eq(true)  # Default
+      expect(options[:text]).to eq(true)      # Default
+    end
+
+    it 'handles complex quoted strings with multiple options' do
+      ENV['RIKA_OPTIONS'] = '"--format=JJ" "--no-metadata" "--text=yes"'
+      options, = ArgsParser.call([])
+      expect(options[:format]).to eq('JJ')
+      expect(options[:metadata]).to eq(false)
+      expect(options[:text]).to eq(true)
+    end
+
+    it 'ignores empty environment variable' do
+      ENV['RIKA_OPTIONS'] = ''
+      options, = ArgsParser.call([])
+      # Should use default values
+      expect(options[:metadata]).to eq(true)
+      expect(options[:text]).to eq(true)
+      expect(options[:key_sort]).to eq(true)
+    end
+
+    it 'handles environment variable with only whitespace' do
+      ENV['RIKA_OPTIONS'] = '   '
+      options, = ArgsParser.call([])
+      # Should use default values
+      expect(options[:metadata]).to eq(true)
+      expect(options[:text]).to eq(true)
+      expect(options[:key_sort]).to eq(true)
+    end
+  end
+
+  describe 'interaction with command-line arguments' do
+    it 'correctly combines environment variables and command-line arguments' do
+      ENV['RIKA_OPTIONS'] = '-f JJ -m- -t-'
+      options, = ArgsParser.call(['-k-', '-s-'])
+      expect(options[:format]).to eq('JJ')
+      expect(options[:metadata]).to eq(false)
+      expect(options[:text]).to eq(false)
+      expect(options[:key_sort]).to eq(false)
+      expect(options[:source]).to eq(false)
+    end
+
+    it 'allows environment-set format to be overridden by command line' do
+      ENV['RIKA_OPTIONS'] = '-f JJ'
+      options, = ArgsParser.call(['-f', 'yy'])
+      expect(options[:format]).to eq('yy')
+    end
+
+    it 'processes options in correct order (env vars first, then command line)' do
+      ENV['RIKA_OPTIONS'] = '-m- -t- -k-'
+      options, = ArgsParser.call(['-m', '-t+', '-k'])
+      expect(options[:metadata]).to eq(true)
+      expect(options[:text]).to eq(true)
+      expect(options[:key_sort]).to eq(true)
+    end
+  end
+end