sentiment_insights 0.2.0 → 0.4.0

data/lib/sentiment_insights/export/excel_exporter.rb

@@ -0,0 +1,334 @@
+require_relative 'base_exporter'
+
+begin
+  require 'rubyXL'
+rescue LoadError
+  puts "Warning: rubyXL gem not found. Excel export will not be available."
+  puts "Install with: gem install rubyXL"
+end
+
+module SentimentInsights
+  module Export
+    class ExcelExporter < BaseExporter
+      def export(filename = nil)
+        raise "rubyXL gem is required for Excel export" unless defined?(RubyXL)
+        
+        filename ||= generate_filename("xlsx")
+        
+        # Apply filters if specified
+        filtered_result = apply_filters(@result)
+        
+        workbook = RubyXL::Workbook.new
+        
+        # Remove the default worksheet
+        workbook.worksheets.delete_at(0)
+        
+        # Create worksheets based on analysis type and options
+        create_responses_sheet(workbook, filtered_result)
+        create_summary_sheet(workbook) if options[:include_summary]
+        create_segments_sheet(workbook) if options[:include_segments]
+        
+        case analysis_type
+        when :entities
+          create_entities_sheet(workbook, filtered_result)
+        when :key_phrases
+          create_phrases_sheet(workbook, filtered_result)
+        end
+        
+        workbook.write(filename)
+        filename
+      end
+
+      private
+
+      def create_responses_sheet(workbook, data)
+        worksheet = workbook.add_worksheet("Responses")
+        
+        # Write headers
+        headers = build_headers
+        write_excel_row(worksheet, 0, headers, bold: true)
+        
+        # Write data rows
+        write_response_data(worksheet, data, start_row: 1)
+        
+        # Auto-size columns
+        auto_size_columns(worksheet, headers.length)
+        
+        worksheet
+      end
+
+      def create_summary_sheet(workbook)
+        worksheet = workbook.add_worksheet("Summary")
+        
+        summary_data = extract_summary_data
+        row = 0
+        
+        # Title
+        worksheet.add_cell(row, 0, "SUMMARY STATISTICS")
+        row += 2
+        
+        # Summary data
+        summary_data.each do |key, value|
+          worksheet.add_cell(row, 0, key)
+          worksheet.add_cell(row, 1, value)
+          row += 1
+        end
+        
+        auto_size_columns(worksheet, 2)
+        worksheet
+      end
+
+      def create_segments_sheet(workbook)
+        segment_data = extract_segment_data
+        return unless segment_data.any?
+        
+        worksheet = workbook.add_worksheet("Segment Analysis")
+        
+        # Title
+        worksheet.add_cell(0, 0, "SEGMENT ANALYSIS")
+        
+        # Headers
+        headers = ["Segment Type", "Segment Value", "Total Count", "Positive %", "Neutral %", "Negative %", "Net Score"]
+        write_excel_row(worksheet, 2, headers, bold: true)
+        
+        # Data
+        segment_data.each_with_index do |segment, index|
+          row = 3 + index
+          write_excel_row(worksheet, row, [
+            segment[:segment_type],
+            segment[:segment_value],
+            segment[:total_count],
+            segment[:positive_percentage],
+            segment[:neutral_percentage],
+            segment[:negative_percentage],
+            segment[:net_score]
+          ])
+        end
+        
+        auto_size_columns(worksheet, headers.length)
+        worksheet
+      end
+
+      def create_entities_sheet(workbook, data)
+        return unless data[:entities]
+        
+        worksheet = workbook.add_worksheet("Entity Details")
+        
+        # Title
+        worksheet.add_cell(0, 0, "ENTITY ANALYSIS")
+        
+        # Headers
+        headers = ["Entity", "Type", "Total Mentions", "Response IDs", "Segment Distribution"]
+        write_excel_row(worksheet, 2, headers, bold: true)
+        
+        # Data
+        data[:entities].each_with_index do |entity, index|
+          row = 3 + index
+          segment_dist = build_segment_distribution(entity[:mentions] || [])
+          
+          write_excel_row(worksheet, row, [
+            entity[:entity],
+            entity[:type],
+            entity[:mentions]&.length || 0,
+            (entity[:mentions] || []).join(", "),
+            format_segment_distribution(segment_dist)
+          ])
+        end
+        
+        auto_size_columns(worksheet, headers.length)
+        worksheet
+      end
+
+      def create_phrases_sheet(workbook, data)
+        return unless data[:phrases]
+        
+        worksheet = workbook.add_worksheet("Phrase Details")
+        
+        # Title
+        worksheet.add_cell(0, 0, "KEY PHRASE ANALYSIS")
+        
+        # Headers
+        headers = ["Phrase", "Total Mentions", "Response IDs", "Sentiment Distribution", "Segment Distribution"]
+        write_excel_row(worksheet, 2, headers, bold: true)
+        
+        # Data
+        data[:phrases].each_with_index do |phrase, index|
+          row = 3 + index
+          sentiment_dist = build_phrase_sentiment_distribution(phrase[:mentions] || [])
+          segment_dist = build_segment_distribution(phrase[:mentions] || [])
+          
+          write_excel_row(worksheet, row, [
+            phrase[:phrase],
+            phrase[:mentions]&.length || 0,
+            (phrase[:mentions] || []).join(", "),
+            format_sentiment_distribution(sentiment_dist),
+            format_segment_distribution(segment_dist)
+          ])
+        end
+        
+        auto_size_columns(worksheet, headers.length)
+        worksheet
+      end
+
+      def write_response_data(worksheet, data, start_row: 0)
+        segment_keys = detect_all_segment_keys
+        
+        responses = case analysis_type
+                   when :sentiment
+                     data[:responses] || []
+                   when :entities
+                     build_entity_response_rows(data)
+                   when :key_phrases
+                     build_phrase_response_rows(data)
+                   else
+                     data[:responses] || []
+                   end
+
+        responses.each_with_index do |response, index|
+          row = start_row + index
+          row_data = build_base_row(response, index)
+          row_data += extract_segment_values(response[:segment], segment_keys)
+          row_data << format_timestamp if options[:include_timestamp]
+          
+          write_excel_row(worksheet, row, row_data)
+        end
+      end
+
+      def write_excel_row(worksheet, row_index, data, bold: false)
+        data.each_with_index do |value, col_index|
+          worksheet.add_cell(row_index, col_index, value)
+        end
+      end
+
+      def auto_size_columns(worksheet, column_count)
+        # Basic implementation - rubyXL doesn't have auto-sizing
+        # Column width is set to a reasonable default
+      end
+
+      # Reuse methods from CSV exporter
+      def build_entity_response_rows(data)
+        responses = data[:responses] || []
+        entities_by_response = build_entities_lookup(data[:entities] || [])
+        
+        responses.map do |response|
+          response_entities = entities_by_response[response[:id]] || []
+          response.merge(entities_found: format_entities_list(response_entities))
+        end
+      end
+
+      def build_phrase_response_rows(data)
+        responses = data[:responses] || []
+        phrases_by_response = build_phrases_lookup(data[:phrases] || [])
+        
+        responses.map do |response|
+          response_phrases = phrases_by_response[response[:id]] || []
+          response.merge(phrases_found: response_phrases.join(", "))
+        end
+      end
+
+      def build_entities_lookup(entities)
+        lookup = Hash.new { |h, k| h[k] = [] }
+        
+        entities.each do |entity|
+          mentions = entity[:mentions] || []
+          mentions.each do |response_id|
+            lookup[response_id] << {
+              text: entity[:entity],
+              type: entity[:type]
+            }
+          end
+        end
+        
+        lookup
+      end
+
+      def build_phrases_lookup(phrases)
+        lookup = Hash.new { |h, k| h[k] = [] }
+        
+        phrases.each do |phrase|
+          mentions = phrase[:mentions] || []
+          mentions.each do |response_id|
+            lookup[response_id] << phrase[:phrase]
+          end
+        end
+        
+        lookup
+      end
+
+      def format_entities_list(entities)
+        entities.map { |e| "#{e[:text]}:#{e[:type]}" }.join(", ")
+      end
+
+      def build_segment_distribution(response_ids)
+        distribution = Hash.new { |h, k| h[k] = Hash.new(0) }
+        
+        response_ids.each do |response_id|
+          response = find_response_by_id(response_id)
+          next unless response && response[:segment]
+          
+          response[:segment].each do |segment_type, segment_value|
+            distribution[segment_type][segment_value] += 1
+          end
+        end
+        
+        distribution
+      end
+
+      def build_phrase_sentiment_distribution(response_ids)
+        distribution = Hash.new(0)
+        
+        response_ids.each do |response_id|
+          response = find_response_by_id(response_id)
+          next unless response
+          
+          sentiment = response[:sentiment] || response[:sentiment_label] || "neutral"
+          distribution[sentiment.to_s] += 1
+        end
+        
+        distribution
+      end
+
+      def find_response_by_id(response_id)
+        responses = extract_responses_data
+        responses.find { |r| r[:id] == response_id }
+      end
+
+      def format_sentiment_distribution(distribution)
+        distribution.map { |sentiment, count| "#{sentiment}:#{count}" }.join(", ")
+      end
+
+      def format_segment_distribution(distribution)
+        parts = []
+        distribution.each do |segment_type, values|
+          values.each do |value, count|
+            parts << "#{segment_type}_#{value}:#{count}"
+          end
+        end
+        parts.join(", ")
+      end
+
+      # Override build_base_row for entities and key phrases
+      def build_base_row(response, index)
+        response_id = response[:id] || "r_#{index + 1}"
+        text = response[:sentence] || response[:answer] || ""
+
+        case analysis_type
+        when :sentiment
+          sentiment_label = response[:sentiment_label] || response[:sentiment] || ""
+          sentiment_score = response[:sentiment_score] || 0.0
+          [response_id, text, sentiment_label, sentiment_score]
+        when :entities
+          entities = response[:entities_found] || ""
+          [response_id, text, entities]
+        when :key_phrases
+          sentiment = response[:sentiment] || ""
+          sentiment_score = response[:sentiment_score] || 0.0
+          phrases = response[:phrases_found] || ""
+          [response_id, text, sentiment, sentiment_score, phrases]
+        else
+          [response_id, text]
+        end
+      end
+    end
+  end
+end

data/lib/sentiment_insights/export/exportable.rb

@@ -0,0 +1,152 @@
+require_relative 'exporter'
+
+module SentimentInsights
+  module Export
+    # Module to be extended on result hashes to add export functionality
+    module Exportable
+      # Export to CSV format
+      # @param filename [String, nil] Optional filename. If nil, auto-generates timestamp-based name
+      # @param options [Hash] Export options
+      # @return [String] Path to exported file
+      def to_csv(filename = nil, options = {})
+        merged_options = (@export_options || {}).merge(options)
+        exporter = SentimentInsights::Export::Exporter.new(self, merged_options)
+        exporter.to_csv(filename)
+      end
+
+      # Export to Excel format
+      # @param filename [String, nil] Optional filename. If nil, auto-generates timestamp-based name  
+      # @param options [Hash] Export options
+      # @return [String] Path to exported file
+      def to_excel(filename = nil, options = {})
+        merged_options = (@export_options || {}).merge(options)
+        exporter = SentimentInsights::Export::Exporter.new(self, merged_options)
+        exporter.to_excel(filename)
+      end
+
+      # Export to JSON format
+      # @param filename [String, nil] Optional filename. If nil, auto-generates timestamp-based name
+      # @param options [Hash] Export options
+      # @return [String] Path to exported file
+      def to_json(filename = nil, options = {})
+        merged_options = (@export_options || {}).merge(options)
+        exporter = SentimentInsights::Export::Exporter.new(self, merged_options)
+        exporter.to_json(filename)
+      end
+
+      # Return JSON as string (for API responses)
+      # @param options [Hash] Export options
+      # @return [String] JSON string
+      def to_json_string(options = {})
+        merged_options = (@export_options || {}).merge(options)
+        exporter = SentimentInsights::Export::Exporter.new(self, merged_options)
+        exporter.to_json_string
+      end
+
+      # Return as hash structure (for API responses)
+      # @param options [Hash] Export options
+      # @return [Hash] Structured data hash
+      def to_hash(options = {})
+        merged_options = (@export_options || {}).merge(options)
+        exporter = SentimentInsights::Export::Exporter.new(self, merged_options)
+        exporter.to_hash
+      end
+
+      # Export to specified format (auto-detects from filename extension)
+      # @param filename_or_format [String, Symbol] Filename with extension or format symbol (:csv, :excel)
+      # @param options [Hash] Export options
+      # @return [String] Path to exported file
+      def export(filename_or_format = nil, options = {})
+        merged_options = (@export_options || {}).merge(options)
+        exporter = SentimentInsights::Export::Exporter.new(self, merged_options)
+        exporter.export(filename_or_format)
+      end
+
+      # Create an exporter instance for advanced operations
+      # @param options [Hash] Export options
+      # @return [SentimentInsights::Export::Exporter] Exporter instance
+      def exporter(options = {})
+        merged_options = (@export_options || {}).merge(options)
+        SentimentInsights::Export::Exporter.new(self, merged_options)
+      end
+
+      # Quick export methods with common filters
+      
+      # Export only positive responses
+      def export_positive(format = :csv, filename = nil)
+        exporter.positive_only(format, filename)
+      end
+
+      # Export only negative responses  
+      def export_negative(format = :csv, filename = nil)
+        exporter.negative_only(format, filename)
+      end
+
+      # Export responses from specific segments
+      def export_by_segment(segment_type, segment_values, format = :csv, filename = nil)
+        exporter.by_segment(segment_type, segment_values, format, filename)
+      end
+
+      # Export to both CSV and Excel formats
+      def export_all(base_filename = nil)
+        exporter.export_all(base_filename)
+      end
+
+      # Configuration methods for fluent interface
+      
+      # Configure export with options and return self for chaining
+      def with_export_options(options)
+        @export_options = (@export_options || {}).merge(options)
+        self
+      end
+
+      # Export only summary data (no individual responses)
+      def summary_only
+        with_export_options(include_segments: false, summary_only: true)
+      end
+
+      # Export only response data (no summary/segments)
+      def responses_only
+        with_export_options(include_summary: false, include_segments: false)
+      end
+
+      # Include detailed segment analysis
+      def with_segments
+        with_export_options(include_segments: true)
+      end
+
+      # Exclude segment analysis
+      def without_segments
+        with_export_options(include_segments: false)
+      end
+
+      # Filter by sentiment
+      def filter_sentiment(*sentiments)
+        with_export_options(filter: { sentiment: sentiments.flatten })
+      end
+
+      # Filter by segment criteria
+      def filter_segments(segment_filters)
+        current_filter = @export_options&.dig(:filter) || {}
+        new_filter = current_filter.merge(segments: segment_filters)
+        with_export_options(filter: new_filter)
+      end
+
+    end
+
+    # Result class that wraps analysis results with export functionality
+    class Result < Hash
+      include Exportable
+
+      def initialize(data = {})
+        super()
+        merge!(data)
+      end
+
+      # Factory method to create Result from analysis output
+      def self.wrap(analysis_result)
+        new(analysis_result)
+      end
+    end
+  end
+end

data/lib/sentiment_insights/export/exporter.rb

@@ -0,0 +1,169 @@
+require_relative 'csv_exporter'
+require_relative 'excel_exporter'
+require_relative 'json_exporter'
+
+module SentimentInsights
+  module Export
+    class Exporter
+      attr_reader :result, :options
+
+      def initialize(result, options = {})
+        @result = result
+        @options = options
+      end
+
+      # Main export method - auto-detects format from filename
+      def export(filename_or_format = nil, options = {})
+        merged_options = @options.merge(options)
+        
+        if filename_or_format.nil?
+          # Default to CSV with auto-generated filename
+          to_csv(nil, merged_options)
+        elsif filename_or_format.is_a?(Symbol)
+          # Format specified as symbol
+          case filename_or_format
+          when :csv
+            to_csv(nil, merged_options)
+          when :excel, :xlsx
+            to_excel(nil, merged_options)
+          when :json
+            to_json(nil, merged_options)
+          else
+            raise ArgumentError, "Unsupported export format: #{filename_or_format}"
+          end
+        else
+          # Filename specified - detect format from extension
+          extension = File.extname(filename_or_format).downcase
+          case extension
+          when '.csv'
+            to_csv(filename_or_format, merged_options)
+          when '.xlsx', '.xls'
+            to_excel(filename_or_format, merged_options)
+          when '.json'
+            to_json(filename_or_format, merged_options)
+          else
+            # Default to CSV if no extension or unknown extension
+            csv_filename = filename_or_format.include?('.') ? filename_or_format : "#{filename_or_format}.csv"
+            to_csv(csv_filename, merged_options)
+          end
+        end
+      end
+
+      # Specific format methods
+      def to_csv(filename = nil, options = {})
+        merged_options = @options.merge(options)
+        CsvExporter.new(@result, merged_options).export(filename)
+      end
+
+      def to_excel(filename = nil, options = {})
+        merged_options = @options.merge(options)
+        ExcelExporter.new(@result, merged_options).export(filename)
+      end
+
+      def to_json(filename = nil, options = {})
+        merged_options = @options.merge(options)
+        JsonExporter.new(@result, merged_options).export(filename)
+      end
+
+      # Return JSON as string (for API responses)
+      def to_json_string(options = {})
+        merged_options = @options.merge(options)
+        JsonExporter.new(@result, merged_options).to_json_string
+      end
+
+      # Return as hash (for API responses)
+      def to_hash(options = {})
+        merged_options = @options.merge(options)
+        JsonExporter.new(@result, merged_options).to_hash
+      end
+
+      # Convenience methods for common export scenarios
+      def to_csv_summary_only(filename = nil)
+        to_csv(filename, include_segments: false)
+      end
+
+      def to_csv_responses_only(filename = nil)
+        to_csv(filename, include_summary: false, include_segments: false)
+      end
+
+      def to_excel_detailed(filename = nil)
+        to_excel(filename, include_summary: true, include_segments: true)
+      end
+
+      # Filtered exports
+      def positive_only(format = :csv, filename = nil)
+        options = { filter: { sentiment: [:positive] } }
+        
+        case format
+        when :csv
+          to_csv(filename, options)
+        when :excel, :xlsx
+          to_excel(filename, options)
+        else
+          raise ArgumentError, "Unsupported format: #{format}"
+        end
+      end
+
+      def negative_only(format = :csv, filename = nil)
+        options = { filter: { sentiment: [:negative] } }
+        
+        case format
+        when :csv
+          to_csv(filename, options)
+        when :excel, :xlsx
+          to_excel(filename, options)
+        else
+          raise ArgumentError, "Unsupported format: #{format}"
+        end
+      end
+
+      def by_segment(segment_type, segment_values, format = :csv, filename = nil)
+        options = { 
+          filter: { 
+            segments: { segment_type.to_sym => Array(segment_values) } 
+          } 
+        }
+        
+        case format
+        when :csv
+          to_csv(filename, options)
+        when :excel, :xlsx
+          to_excel(filename, options)
+        else
+          raise ArgumentError, "Unsupported format: #{format}"
+        end
+      end
+
+      # Batch export - multiple formats at once
+      def export_all(base_filename = nil)
+        base_name = base_filename || detect_base_filename
+        
+        files = {}
+        files[:csv] = to_csv("#{base_name}.csv")
+        
+        begin
+          files[:excel] = to_excel("#{base_name}.xlsx")
+        rescue => e
+          puts "Warning: Excel export failed: #{e.message}"
+        end
+        
+        files
+      end
+
+      private
+
+      def detect_base_filename
+        analysis_type = detect_analysis_type(@result)
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        "#{analysis_type}_analysis_#{timestamp}"
+      end
+
+      def detect_analysis_type(result)
+        return :sentiment if result.key?(:global_summary) || result.key?(:responses)
+        return :entities if result.key?(:entities)
+        return :key_phrases if result.key?(:phrases)
+        :unknown
+      end
+    end
+  end
+end