legal_summariser 0.2.0 → 0.3.1

data/examples/basic_usage.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Basic usage of Legal Summariser gem
+require 'legal_summariser'
+
+# Configure the gem (optional)
+LegalSummariser.configure do |config|
+  config.language = 'en'
+  config.enable_caching = true
+  config.max_file_size = 10 * 1024 * 1024 # 10MB
+end
+
+# Example 1: Basic document analysis
+puts "=== Basic Document Analysis ==="
+begin
+  # Analyze a document (replace with your actual file path)
+  result = LegalSummariser.summarise('sample_contract.pdf')
+  
+  puts "Document Type: #{result[:metadata][:document_type]}"
+  puts "Word Count: #{result[:metadata][:word_count]}"
+  puts "\nSummary:"
+  puts result[:plain_text]
+  
+  puts "\nKey Points:"
+  result[:key_points].each_with_index do |point, index|
+    puts "#{index + 1}. #{point}"
+  end
+  
+rescue LegalSummariser::DocumentNotFoundError => e
+  puts "Error: #{e.message}"
+rescue LegalSummariser::UnsupportedFormatError => e
+  puts "Error: #{e.message}"
+end
+
+# Example 2: Analysis with custom options
+puts "\n=== Custom Analysis Options ==="
+options = {
+  max_sentences: 3,
+  format: 'markdown'
+}
+
+begin
+  result = LegalSummariser.summarise('sample_contract.pdf', options)
+  puts result
+rescue => e
+  puts "Error: #{e.message}"
+end
+
+# Example 3: Risk analysis focus
+puts "\n=== Risk Analysis ==="
+begin
+  result = LegalSummariser.summarise('sample_contract.pdf')
+  
+  risks = result[:risks]
+  puts "Overall Risk Level: #{risks[:risk_score][:level].upcase}"
+  puts "Risk Score: #{risks[:risk_score][:score]}"
+  
+  if risks[:high_risks].any?
+    puts "\nHigh Risks Found:"
+    risks[:high_risks].each do |risk|
+      puts "- #{risk[:type]}: #{risk[:description]}"
+      puts "  Recommendation: #{risk[:recommendation]}"
+    end
+  end
+  
+  if risks[:compliance_gaps].any?
+    puts "\nCompliance Gaps:"
+    risks[:compliance_gaps].each do |gap|
+      puts "- #{gap[:type]} (#{gap[:regulation]}): #{gap[:description]}"
+    end
+  end
+  
+rescue => e
+  puts "Error: #{e.message}"
+end
+
+# Example 4: Clause detection
+puts "\n=== Clause Detection ==="
+begin
+  result = LegalSummariser.summarise('sample_contract.pdf')
+  
+  result[:clauses].each do |clause_type, clauses|
+    next if clauses.empty?
+    
+    puts "\n#{clause_type.to_s.split('_').map(&:capitalize).join(' ')} Clauses:"
+    clauses.each_with_index do |clause, index|
+      puts "#{index + 1}. #{clause[:content][0..100]}..."
+    end
+  end
+  
+rescue => e
+  puts "Error: #{e.message}"
+end
+
+# Example 5: Performance monitoring
+puts "\n=== Performance Statistics ==="
+stats = LegalSummariser.stats
+puts "Performance: #{stats[:performance]}"
+puts "Cache: #{stats[:cache]}"
+puts "Memory: #{stats[:memory]}"

data/examples/batch_processing.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Batch processing multiple legal documents
+require 'legal_summariser'
+
+# Configure for batch processing
+LegalSummariser.configure do |config|
+  config.enable_caching = true
+  config.logger = Logger.new(STDOUT, level: Logger::INFO)
+end
+
+# Example file paths (replace with your actual files)
+file_paths = [
+  'contracts/nda_company_a.pdf',
+  'contracts/service_agreement_b.docx',
+  'contracts/employment_contract_c.txt',
+  'policies/privacy_policy.pdf'
+]
+
+puts "=== Batch Processing Legal Documents ==="
+puts "Processing #{file_paths.length} documents..."
+
+# Batch process all documents
+results = LegalSummariser.batch_summarise(file_paths, {
+  format: 'json',
+  max_sentences: 4
+})
+
+# Analyze results
+successful = results.select { |r| r[:success] }
+failed = results.reject { |r| r[:success] }
+
+puts "\nBatch Processing Results:"
+puts "✓ Successful: #{successful.length}"
+puts "✗ Failed: #{failed.length}"
+
+# Process successful results
+if successful.any?
+  puts "\n=== Successful Analyses ==="
+  
+  successful.each do |result|
+    analysis = JSON.parse(result[:result], symbolize_names: true)
+    
+    puts "\nFile: #{File.basename(result[:file_path])}"
+    puts "Type: #{analysis[:metadata][:document_type]}"
+    puts "Words: #{analysis[:metadata][:word_count]}"
+    puts "Risk Level: #{analysis[:risks][:risk_score][:level].upcase}"
+    
+    # Show key risks
+    high_risks = analysis[:risks][:high_risks]
+    if high_risks.any?
+      puts "High Risks: #{high_risks.map { |r| r[:type] }.join(', ')}"
+    end
+  end
+  
+  # Generate summary report
+  puts "\n=== Summary Report ==="
+  
+  # Document type distribution
+  doc_types = successful.map do |result|
+    JSON.parse(result[:result], symbolize_names: true)[:metadata][:document_type]
+  end
+  
+  type_counts = doc_types.group_by(&:itself).transform_values(&:count)
+  puts "Document Types:"
+  type_counts.each { |type, count| puts "  #{type}: #{count}" }
+  
+  # Risk level distribution
+  risk_levels = successful.map do |result|
+    JSON.parse(result[:result], symbolize_names: true)[:risks][:risk_score][:level]
+  end
+  
+  risk_counts = risk_levels.group_by(&:itself).transform_values(&:count)
+  puts "Risk Levels:"
+  risk_counts.each { |level, count| puts "  #{level}: #{count}" }
+  
+  # Average processing metrics
+  word_counts = successful.map do |result|
+    JSON.parse(result[:result], symbolize_names: true)[:metadata][:word_count]
+  end
+  
+  avg_words = word_counts.sum.to_f / word_counts.length
+  puts "Average Document Size: #{avg_words.round} words"
+end
+
+# Show failed analyses
+if failed.any?
+  puts "\n=== Failed Analyses ==="
+  failed.each do |result|
+    puts "✗ #{File.basename(result[:file_path])}: #{result[:error]}"
+  end
+end
+
+# Export results to files
+puts "\n=== Exporting Results ==="
+require 'fileutils'
+
+output_dir = 'analysis_results'
+FileUtils.mkdir_p(output_dir)
+
+successful.each do |result|
+  filename = File.basename(result[:file_path], '.*')
+  output_file = File.join(output_dir, "#{filename}_analysis.json")
+  
+  File.write(output_file, result[:result])
+  puts "Exported: #{output_file}"
+end
+
+# Generate consolidated report
+consolidated_report = {
+  processed_at: Time.now.iso8601,
+  total_files: file_paths.length,
+  successful: successful.length,
+  failed: failed.length,
+  results: results
+}
+
+report_file = File.join(output_dir, 'batch_report.json')
+File.write(report_file, JSON.pretty_generate(consolidated_report))
+puts "Consolidated report: #{report_file}"
+
+puts "\nBatch processing completed!"

data/lib/legal_summariser/cache.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'fileutils'
+
+module LegalSummariser
+  # Caching system for analysis results
+  class Cache
+    def initialize(cache_dir = nil)
+      @cache_dir = cache_dir || LegalSummariser.configuration.cache_dir
+      FileUtils.mkdir_p(@cache_dir) if LegalSummariser.configuration.enable_caching
+    end
+
+    # Generate cache key for a file
+    # @param file_path [String] Path to the file
+    # @param options [Hash] Analysis options
+    # @return [String] Cache key
+    def cache_key(file_path, options = {})
+      file_stat = File.stat(file_path)
+      content = "#{file_path}:#{file_stat.mtime}:#{file_stat.size}:#{options.to_json}"
+      Digest::SHA256.hexdigest(content)
+    end
+
+    # Get cached result
+    # @param key [String] Cache key
+    # @return [Hash, nil] Cached result or nil
+    def get(key)
+      return nil unless LegalSummariser.configuration.enable_caching
+      
+      cache_file = File.join(@cache_dir, "#{key}.json")
+      return nil unless File.exist?(cache_file)
+      
+      # Check if cache is expired (24 hours)
+      return nil if File.mtime(cache_file) < Time.now - (24 * 60 * 60)
+      
+      JSON.parse(File.read(cache_file), symbolize_names: true)
+    rescue JSON::ParserError, Errno::ENOENT
+      nil
+    end
+
+    # Store result in cache
+    # @param key [String] Cache key
+    # @param result [Hash] Result to cache
+    def set(key, result)
+      return unless LegalSummariser.configuration.enable_caching
+      
+      cache_file = File.join(@cache_dir, "#{key}.json")
+      File.write(cache_file, JSON.pretty_generate(result))
+    rescue => e
+      # Silently fail caching - don't break the main functionality
+      LegalSummariser.configuration.logger&.warn("Cache write failed: #{e.message}")
+    end
+
+    # Clear cache
+    def clear!
+      return unless Dir.exist?(@cache_dir)
+      
+      Dir.glob(File.join(@cache_dir, "*.json")).each do |file|
+        File.delete(file)
+      end
+    end
+
+    # Get cache statistics
+    # @return [Hash] Cache statistics
+    def stats
+      return { enabled: false } unless LegalSummariser.configuration.enable_caching
+      
+      cache_files = Dir.glob(File.join(@cache_dir, "*.json"))
+      total_size = cache_files.sum { |file| File.size(file) }
+      
+      {
+        enabled: true,
+        file_count: cache_files.length,
+        total_size_bytes: total_size,
+        total_size_mb: (total_size / 1024.0 / 1024.0).round(2),
+        cache_dir: @cache_dir
+      }
+    end
+  end
+end

data/lib/legal_summariser/configuration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LegalSummariser
+  # Configuration class for gem settings
+  class Configuration
+    attr_accessor :logger, :max_file_size, :timeout, :language, :enable_caching, :cache_dir
+
+    def initialize
+      @logger = nil
+      @max_file_size = 50 * 1024 * 1024 # 50MB default
+      @timeout = 30 # 30 seconds default
+      @language = 'en'
+      @enable_caching = false
+      @cache_dir = '/tmp/legal_summariser_cache'
+    end
+
+    # Supported languages for analysis
+    def supported_languages
+      %w[en tr de fr es it]
+    end
+
+    # Validate configuration
+    def validate!
+      raise Error, "Invalid language: #{@language}" unless supported_languages.include?(@language)
+      raise Error, "Max file size must be positive" if @max_file_size <= 0
+      raise Error, "Timeout must be positive" if @timeout <= 0
+    end
+  end
+
+  # Global configuration
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+    configuration.validate!
+  end
+
+  def self.reset_configuration!
+    @configuration = Configuration.new
+  end
+end