string_to_number 0.2.0 → 0.3.0

data/microbenchmark.rb

@@ -9,10 +9,10 @@ require 'benchmark'
 
 class MicroBenchmark
   def self.run
-    puts "StringToNumber Micro-Benchmarks"
-    puts "=" * 50
+    puts 'StringToNumber Micro-Benchmarks'
+    puts '=' * 50
     puts
-    
+
     # Test individual components
     test_initialization
     test_regex_compilation
@@ -20,43 +20,45 @@ class MicroBenchmark
     test_hash_lookups
     test_string_operations
     test_recursion_overhead
-    
+
     puts "\nConclusions and Recommendations:"
-    puts "=" * 50
+    puts '=' * 50
     analyze_results
   end
 
   def self.test_initialization
-    puts "1. Initialization Performance"
-    puts "-" * 30
-    
+    puts '1. Initialization Performance'
+    puts '-' * 30
+
     # Test the cost of creating new instances
     sentences = ['un', 'vingt et un', 'mille deux cent', 'trois milliards cinq cents millions']
-    
+
     sentences.each do |sentence|
       time = Benchmark.realtime do
         1000.times { StringToNumber::ToNumber.new(sentence) }
       end
-      
+
       puts "#{sentence.ljust(35)}: #{(time * 1000).round(4)}ms per 1000 instances"
     end
     puts
   end
 
   def self.test_regex_compilation
-    puts "2. Regex Compilation Performance"
-    puts "-" * 30
-    
+    puts '2. Regex Compilation Performance'
+    puts '-' * 30
+
     # Test the cost of regex compilation vs pre-compiled regex
-    keys = StringToNumber::ToNumber::POWERS_OF_TEN.keys.reject { |k| %w[un dix].include?(k) }.sort_by(&:length).reverse.join('|')
-    
+    keys = StringToNumber::ToNumber::POWERS_OF_TEN.keys.reject do |k|
+      %w[un dix].include?(k)
+    end.sort_by(&:length).reverse.join('|')
+
     # Dynamic compilation
     dynamic_time = Benchmark.realtime do
       1000.times do
         /(?<f>.*?)\s?(?<m>#{keys})/.match('trois milliards')
       end
     end
-    
+
     # Pre-compiled regex
     compiled_regex = /(?<f>.*?)\s?(?<m>#{Regexp.escape(keys)})/
     precompiled_time = Benchmark.realtime do
@@ -64,7 +66,7 @@ class MicroBenchmark
         compiled_regex.match('trois milliards')
       end
     end
-    
+
     puts "Dynamic regex compilation: #{(dynamic_time * 1000).round(4)}ms per 1000 matches"
     puts "Pre-compiled regex:        #{(precompiled_time * 1000).round(4)}ms per 1000 matches"
     puts "Compilation overhead:      #{((dynamic_time - precompiled_time) * 1000).round(4)}ms per 1000 matches"
@@ -72,62 +74,64 @@ class MicroBenchmark
   end
 
   def self.test_regex_matching
-    puts "3. Regex Pattern Complexity"
-    puts "-" * 30
-    
+    puts '3. Regex Pattern Complexity'
+    puts '-' * 30
+
     # Test different regex patterns to see which are expensive
     test_patterns = {
       'Simple word match' => /vingt/,
       'Word boundary match' => /\bvingt\b/,
       'Named capture groups' => /(?<f>.*?)\s?(?<m>vingt)/,
       'Complex alternation' => /(?<f>.*?)\s?(?<m>vingt|trente|quarante|cinquante)/,
-      'Full keys pattern' => /(?<f>.*?)\s?(?<m>#{StringToNumber::ToNumber::POWERS_OF_TEN.keys.reject { |k| %w[un dix].include?(k) }.sort_by(&:length).reverse.join('|')})/
+      'Full keys pattern' => /(?<f>.*?)\s?(?<m>#{StringToNumber::ToNumber::POWERS_OF_TEN.keys.reject do |k|
+        %w[un dix].include?(k)
+      end.sort_by(&:length).reverse.join('|')})/
     }
-    
+
     test_string = 'trois milliards cinq cents millions'
-    
+
     test_patterns.each do |name, pattern|
       time = Benchmark.realtime do
         5000.times { pattern.match(test_string) }
       end
-      
+
       puts "#{name.ljust(25)}: #{(time * 1000).round(4)}ms per 5000 matches"
     end
     puts
   end
 
   def self.test_hash_lookups
-    puts "4. Hash Lookup Performance"
-    puts "-" * 30
-    
+    puts '4. Hash Lookup Performance'
+    puts '-' * 30
+
     exceptions = StringToNumber::ToNumber::EXCEPTIONS
     powers = StringToNumber::ToNumber::POWERS_OF_TEN
-    
+
     # Test lookup performance
     exceptions_time = Benchmark.realtime do
-      10000.times do
+      10_000.times do
         exceptions['vingt']
         exceptions['trois']
         exceptions['cent']
       end
     end
-    
+
     powers_time = Benchmark.realtime do
-      10000.times do
+      10_000.times do
         powers['million']
         powers['mille']
         powers['cent']
       end
     end
-    
+
     # Test nil checks
     nil_check_time = Benchmark.realtime do
-      10000.times do
+      10_000.times do
         exceptions['nonexistent'].nil?
         powers['nonexistent'].nil?
       end
     end
-    
+
     puts "EXCEPTIONS hash lookups:   #{(exceptions_time * 100).round(4)}ms per 10000 lookups"
     puts "POWERS_OF_TEN hash lookups: #{(powers_time * 100).round(4)}ms per 10000 lookups"
     puts "Nil check operations:      #{(nil_check_time * 100).round(4)}ms per 10000 checks"
@@ -135,28 +139,28 @@ class MicroBenchmark
   end
 
   def self.test_string_operations
-    puts "5. String Operations Performance"
-    puts "-" * 30
-    
+    puts '5. String Operations Performance'
+    puts '-' * 30
+
     test_string = 'TROIS MILLIARDS CINQ CENTS MILLIONS'
-    
+
     # Test different string operations
     downcase_time = Benchmark.realtime do
       5000.times { test_string.downcase }
     end
-    
+
     gsub_time = Benchmark.realtime do
-      5000.times { test_string.gsub(/MILLIONS/, '') }
+      5000.times { test_string.gsub('MILLIONS', '') }
     end
-    
+
     split_time = Benchmark.realtime do
-      5000.times { test_string.split(' ') }
+      5000.times { test_string.split }
     end
-    
+
     tr_time = Benchmark.realtime do
       5000.times { test_string.tr('-', ' ') }
     end
-    
+
     puts "String#downcase:  #{(downcase_time * 1000).round(4)}ms per 5000 operations"
     puts "String#gsub:      #{(gsub_time * 1000).round(4)}ms per 5000 operations"
     puts "String#split:     #{(split_time * 1000).round(4)}ms per 5000 operations"
@@ -165,29 +169,28 @@ class MicroBenchmark
   end
 
   def self.test_recursion_overhead
-    puts "6. Recursion vs Iteration Performance"
-    puts "-" * 30
-    
+    puts '6. Recursion vs Iteration Performance'
+    puts '-' * 30
+
     # Compare recursive vs iterative approaches
-    def self.recursive_sum(arr, index = 0)
+    recursive_sum = lambda do |arr, index = 0|
       return 0 if index >= arr.length
-      arr[index] + recursive_sum(arr, index + 1)
-    end
-    
-    def self.iterative_sum(arr)
-      arr.sum
+
+      arr[index] + recursive_sum.call(arr, index + 1)
     end
-    
+
+    iterative_sum = :sum.to_proc
+
     test_array = Array.new(100) { rand(100) }
-    
+
     recursive_time = Benchmark.realtime do
-      1000.times { recursive_sum(test_array) }
+      1000.times { recursive_sum.call(test_array) }
     end
-    
+
     iterative_time = Benchmark.realtime do
-      1000.times { iterative_sum(test_array) }
+      1000.times { iterative_sum.call(test_array) }
     end
-    
+
     puts "Recursive approach: #{(recursive_time * 1000).round(4)}ms per 1000 operations"
     puts "Iterative approach: #{(iterative_time * 1000).round(4)}ms per 1000 operations"
     puts "Recursion overhead: #{((recursive_time - iterative_time) * 1000).round(4)}ms per 1000 operations"
@@ -195,32 +198,30 @@ class MicroBenchmark
   end
 
   def self.analyze_results
-    puts "Key Performance Insights:"
+    puts 'Key Performance Insights:'
     puts
-    puts "1. 🔍 INITIALIZATION COST:"
-    puts "   - Creating new ToNumber instances is expensive (~13ms per 1000)"
-    puts "   - Consider caching or singleton pattern for repeated use"
+    puts '1. 🔍 INITIALIZATION COST:'
+    puts '   - Creating new ToNumber instances is expensive (~13ms per 1000)'
+    puts '   - Consider caching or singleton pattern for repeated use'
     puts
-    puts "2. 🔍 REGEX COMPLEXITY:"
-    puts "   - Complex alternation patterns are the main bottleneck"
-    puts "   - Keys pattern is 521 characters long - very expensive to match"
-    puts "   - Consider breaking down into simpler patterns or using different approach"
+    puts '2. 🔍 REGEX COMPLEXITY:'
+    puts '   - Complex alternation patterns are the main bottleneck'
+    puts '   - Keys pattern is 521 characters long - very expensive to match'
+    puts '   - Consider breaking down into simpler patterns or using different approach'
     puts
-    puts "3. 🔍 SCALABILITY ISSUES:"
-    puts "   - Performance degrades significantly with input length (43x for longest)"
-    puts "   - Recursive parsing creates overhead for complex numbers"
-    puts "   - String operations add up with multiple passes"
+    puts '3. 🔍 SCALABILITY ISSUES:'
+    puts '   - Performance degrades significantly with input length (43x for longest)'
+    puts '   - Recursive parsing creates overhead for complex numbers'
+    puts '   - String operations add up with multiple passes'
     puts
-    puts "📊 OPTIMIZATION RECOMMENDATIONS:"
-    puts "   1. Pre-compile regex patterns in class constants"
-    puts "   2. Use simpler regex patterns with multiple passes if needed"
-    puts "   3. Implement caching for repeated conversions"
-    puts "   4. Consider iterative parsing instead of recursive for complex cases"
-    puts "   5. Optimize string operations (minimize downcase/gsub calls)"
+    puts '📊 OPTIMIZATION RECOMMENDATIONS:'
+    puts '   1. Pre-compile regex patterns in class constants'
+    puts '   2. Use simpler regex patterns with multiple passes if needed'
+    puts '   3. Implement caching for repeated conversions'
+    puts '   4. Consider iterative parsing instead of recursive for complex cases'
+    puts '   5. Optimize string operations (minimize downcase/gsub calls)'
   end
 end
 
 # Run the micro-benchmarks
-if __FILE__ == $0
-  MicroBenchmark.run
-end
+MicroBenchmark.run if __FILE__ == $PROGRAM_NAME

data/performance_comparison.rb

@@ -16,20 +16,20 @@ class PerformanceComparison
   ].freeze
 
   def self.run_comparison
-    puts "StringToNumber Performance Comparison"
-    puts "=" * 60
-    puts "Original vs Optimized Implementation"
-    puts "=" * 60
+    puts 'StringToNumber Performance Comparison'
+    puts '=' * 60
+    puts 'Original vs Optimized Implementation'
+    puts '=' * 60
     puts
 
     TEST_CASES.each_with_index do |test_case, index|
       puts "Test #{index + 1}: '#{test_case}'"
-      puts "-" * 50
+      puts '-' * 50
 
       # Verify both implementations produce same results
       original_result = StringToNumber.in_numbers(test_case, use_optimized: false)
       optimized_result = StringToNumber.in_numbers(test_case, use_optimized: true)
-      
+
       if original_result == optimized_result
         puts "✅ Results match: #{original_result}"
       else
@@ -38,7 +38,7 @@ class PerformanceComparison
       end
 
       # Benchmark both implementations
-      iterations = 10000
+      iterations = 10_000
 
       original_time = Benchmark.realtime do
         iterations.times { StringToNumber.in_numbers(test_case, use_optimized: false) }
@@ -55,27 +55,27 @@ class PerformanceComparison
       puts "Original:  #{original_avg.round(4)}ms average"
       puts "Optimized: #{optimized_avg.round(4)}ms average"
       puts "Speedup:   #{speedup.round(1)}x faster"
-      
+
       # Performance rating
       rating = case speedup
-               when 0..2 then "🟡 Minor improvement"
-               when 2..10 then "🟢 Good improvement"
-               when 10..50 then "🟢 Great improvement"
-               else "🚀 Exceptional improvement"
+               when 0..2 then '🟡 Minor improvement'
+               when 2..10 then '🟢 Good improvement'
+               when 10..50 then '🟢 Great improvement'
+               else '🚀 Exceptional improvement'
                end
-      
+
       puts "Rating:    #{rating}"
       puts
     end
 
     # Overall comparison
-    puts "=" * 60
-    puts "OVERALL PERFORMANCE ANALYSIS"
-    puts "=" * 60
+    puts '=' * 60
+    puts 'OVERALL PERFORMANCE ANALYSIS'
+    puts '=' * 60
 
     # Test cache performance
     puts "\nCache Performance Test:"
-    puts "-" * 30
+    puts '-' * 30
 
     # Clear caches
     StringToNumber.clear_caches!
@@ -107,17 +107,17 @@ class PerformanceComparison
 
     # Scalability test
     puts "\nScalability Comparison:"
-    puts "-" * 30
+    puts '-' * 30
 
     scalability_tests = [
       'un',                                                           # 2 chars
       'vingt et un',                                                  # 11 chars
-      'mille deux cent trente-quatre',                               # 29 chars
+      'mille deux cent trente-quatre', # 29 chars
       'soixante-quinze million trois cent quarante six mille sept cent quatre-vingt-dix neuf' # 85 chars
     ]
 
-    puts "Input Length | Original | Optimized | Improvement"
-    puts "-------------|----------|-----------|------------"
+    puts 'Input Length | Original | Optimized | Improvement'
+    puts '-------------|----------|-----------|------------'
 
     scalability_tests.each do |test|
       original_time = Benchmark.realtime do
@@ -132,24 +132,23 @@ class PerformanceComparison
       optimized_ms = (optimized_time / 1000) * 1000
       improvement = original_ms / optimized_ms
 
-      puts "#{test.length.to_s.rjust(11)} | #{original_ms.round(4).to_s.rjust(8)} | #{optimized_ms.round(4).to_s.rjust(9)} | #{improvement.round(1).to_s.rjust(10)}x"
+      puts "#{test.length.to_s.rjust(11)} | #{original_ms.round(4).to_s.rjust(8)} | " \
+           "#{optimized_ms.round(4).to_s.rjust(9)} | #{improvement.round(1).to_s.rjust(10)}x"
     end
 
-    puts "\n" + "=" * 60
-    puts "SUMMARY"
-    puts "=" * 60
-    puts "✅ All test cases produce identical results"
-    puts "🚀 Significant performance improvements across all test cases"
-    puts "📈 Better scalability with input length"
-    puts "💾 Effective caching reduces repeated conversion time"
-    puts "🧠 Lower memory usage and object creation"
+    puts "\n#{'=' * 60}"
+    puts 'SUMMARY'
+    puts '=' * 60
+    puts '✅ All test cases produce identical results'
+    puts '🚀 Significant performance improvements across all test cases'
+    puts '📈 Better scalability with input length'
+    puts '💾 Effective caching reduces repeated conversion time'
+    puts '🧠 Lower memory usage and object creation'
     puts
-    puts "The optimized implementation successfully addresses all identified"
-    puts "performance bottlenecks while maintaining full compatibility."
+    puts 'The optimized implementation successfully addresses all identified'
+    puts 'performance bottlenecks while maintaining full compatibility.'
   end
 end
 
 # Run the comparison
-if __FILE__ == $0
-  PerformanceComparison.run_comparison
-end
+PerformanceComparison.run_comparison if __FILE__ == $PROGRAM_NAME

data/profile.rb

@@ -8,93 +8,92 @@ require_relative 'lib/string_to_number'
 
 begin
   require 'ruby-prof'
-  
+
   # Profile the most complex case
   test_input = 'soixante-quinze million trois cent quarante six mille sept cent quatre-vingt-dix neuf'
-  
-  puts "Profiling StringToNumber with input:"
+
+  puts 'Profiling StringToNumber with input:'
   puts "'#{test_input}'"
-  puts "=" * 80
-  
+  puts '=' * 80
+
   # Start profiling
   RubyProf.start
-  
+
   # Run the conversion many times
   5000.times do
     StringToNumber.in_numbers(test_input)
   end
-  
+
   # Stop profiling
   result = RubyProf.stop
-  
+
   # Print results
   puts "\nTop 20 methods by total time:"
-  puts "-" * 80
-  
+  puts '-' * 80
+
   printer = RubyProf::FlatPrinter.new(result)
-  printer.print(STDOUT, min_percent: 1)
-  
+  printer.print($stdout, min_percent: 1)
+
   # Generate call graph
   puts "\n\nCall Graph Analysis:"
-  puts "-" * 80
-  
+  puts '-' * 80
+
   printer = RubyProf::CallTreePrinter.new(result)
   File.open('profile_output.txt', 'w') do |file|
     printer.print(file)
   end
-  puts "Detailed call graph saved to: profile_output.txt"
-  
+  puts 'Detailed call graph saved to: profile_output.txt'
+
   # Method-specific analysis
   puts "\n\nMethod Breakdown:"
-  puts "-" * 80
-  
+  puts '-' * 80
+
   result.threads.each do |thread|
     thread.methods.sort_by(&:total_time).reverse.first(10).each do |method|
       next if method.total_time < 0.01
-      
-      puts "#{method.full_name}"
+
+      puts method.full_name
       puts "  Total time: #{(method.total_time * 1000).round(2)}ms"
       puts "  Calls: #{method.called}"
       puts "  Time per call: #{((method.total_time / method.called) * 1000).round(4)}ms"
       puts
     end
   end
-
 rescue LoadError
-  puts "ruby-prof gem not available. Running basic timing analysis instead."
-  puts "Install with: gem install ruby-prof"
+  puts 'ruby-prof gem not available. Running basic timing analysis instead.'
+  puts 'Install with: gem install ruby-prof'
   puts
-  
+
   # Fallback: manual timing analysis
   require 'benchmark'
-  
+
   test_cases = [
     'un',
-    'vingt et un', 
+    'vingt et un',
     'mille deux cent',
     'trois milliards cinq cents millions'
   ]
-  
-  puts "Manual Performance Analysis:"
-  puts "=" * 40
-  
+
+  puts 'Manual Performance Analysis:'
+  puts '=' * 40
+
   test_cases.each do |input|
     puts "\nAnalyzing: '#{input}'"
-    
+
     # Time different aspects
     parser = nil
     init_time = Benchmark.realtime do
       1000.times { parser = StringToNumber::ToNumber.new(input) }
     end
-    
+
     conversion_time = Benchmark.realtime do
       1000.times { parser.to_number }
     end
-    
+
     total_time = Benchmark.realtime do
       1000.times { StringToNumber.in_numbers(input) }
     end
-    
+
     puts "  Initialization: #{(init_time * 1000).round(4)}ms per 1000 calls"
     puts "  Conversion: #{(conversion_time * 1000).round(4)}ms per 1000 calls"
     puts "  Total: #{(total_time * 1000).round(4)}ms per 1000 calls"
@@ -103,29 +102,29 @@ rescue LoadError
 
   # Test regex performance specifically
   puts "\n\nRegex Performance Test:"
-  puts "=" * 40
-  
-  sample_input = "trois milliards cinq cents millions"
+  puts '=' * 40
+
+  sample_input = 'trois milliards cinq cents millions'
   parser = StringToNumber::ToNumber.new(sample_input)
   keys = parser.instance_variable_get(:@keys)
-  
+
   puts "Keys pattern length: #{keys.length} characters"
-  
+
   regex_time = Benchmark.realtime do
-    10000.times do
+    10_000.times do
       /(?<f>.*?)\s?(?<m>#{keys})/.match(sample_input)
     end
   end
-  
+
   puts "Regex matching time: #{(regex_time * 100).round(4)}ms per 10000 matches"
-  
+
   # Test hash lookup performance
   lookup_time = Benchmark.realtime do
-    100000.times do
+    100_000.times do
       StringToNumber::ToNumber::EXCEPTIONS['vingt']
       StringToNumber::ToNumber::POWERS_OF_TEN['millions']
     end
   end
-  
+
   puts "Hash lookup time: #{(lookup_time * 10).round(4)}ms per 100000 lookups"
-end
+end

data/string_to_number.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'string_to_number/version'
@@ -18,10 +20,11 @@ Gem::Specification.new do |spec|
   # to allow pushing to a single host or delete
   # this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+    spec.metadata['rubygems_mfa_required'] = 'true'
   else
     raise 'RubyGems 2.0 or newer is required to protect against ' \
-      'public gem pushes.'
+          'public gem pushes.'
   end
 
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
@@ -30,8 +33,4 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
 end