berkeley_library-tind 0.4.0

data/lib/berkeley_library/tind/export/no_results_error.rb

@@ -0,0 +1,7 @@
+module BerkeleyLibrary
+  module TIND
+    module Export
+      class NoResultsError < StandardError; end
+    end
+  end
+end

data/lib/berkeley_library/tind/export/ods_exporter.rb

@@ -0,0 +1,138 @@
+require 'berkeley_library/util/arrays'
+require 'berkeley_library/tind/export/exporter'
+require 'berkeley_library/tind/export/table_metrics'
+require 'berkeley_library/util/ods/spreadsheet'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      # Exporter for OpenOffice/LibreOffice format
+      class ODSExporter < Exporter
+
+        LOCKED_CELL_COLOR = '#c0362c'.freeze
+
+        # Round column widths up to nearest quarter inch
+        EIGHTH = '1/8'.to_r
+
+        # Max column width before wrapping
+        MAX_COLUMN_WIDTH_INCHES = 3.0
+
+        # Exports {ExportBase#collection} as an OpenOffice/LibreOffice spreadsheet
+        # @overload export
+        #   Exports to a new string.
+        #   @return [String] a binary string containing the spreadsheet data.
+        # @overload export(out)
+        #   Exports to the specified output stream.
+        #   @param out [IO] the output stream
+        #   @return[void]
+        # @overload export(path)
+        #   Exports to the specified file. If `path` denotes a directory, the
+        #   spreadsheet will be written as exploded, pretty-printed XML.
+        #   @param path [String, Pathname] the path to the output file or directory
+        #   @return[void]
+        #   @see BerkeleyLibrary::Util::ODS::Spreadsheet#write_exploded_to
+        def export(out = nil)
+          populate_spreadsheet!
+          spreadsheet.write_to(out)
+        end
+
+        # ------------------------------------------------------------
+        # Private methods
+
+        private
+
+        # ------------------------------
+        # Private accessors
+
+        def spreadsheet
+          @spreadsheet ||= BerkeleyLibrary::Util::ODS::Spreadsheet.new
+        end
+
+        def table
+          @table ||= spreadsheet.add_table(collection, protected: false)
+        end
+
+        def table_metrics
+          @table_metrics ||= TableMetrics.new(export_table)
+        end
+
+        # @return [BerkeleyLibrary::Util::ODS::XML::Office::AutomaticStyles] the styles
+        def styles
+          spreadsheet.auto_styles
+        end
+
+        def color_for(col_index)
+          can_edit?(col_index) ? nil : LOCKED_CELL_COLOR
+        end
+
+        def header_cell_style_for(col_index)
+          @header_cell_styles ||= []
+          @header_cell_styles[col_index] ||= begin
+            find_or_create_cell_style(
+              color: color_for(col_index),
+              font_weight: 'bold'
+            )
+          end
+        end
+
+        def find_or_create_cell_style(color:, font_weight: nil, wrap: false)
+          styles.find_or_create_cell_style(color: color, font_weight: font_weight, wrap: wrap)
+        end
+
+        def column_style_for(col_index)
+          column_width = table_metrics.formatted_width(col_index)
+          @column_styles_by_width ||= {}
+          @column_styles_by_width[column_width] ||= styles.find_or_create_column_style(column_width)
+        end
+
+        # ------------------------------
+        # Private utility methods
+
+        def populate_spreadsheet!
+          logger.info("Populating spreadsheet for #{collection}")
+          populate_columns!
+          populate_rows!
+        end
+
+        def can_edit?(col_index)
+          raise ArgumentError, "Invalid column index: #{col_index.inspect}" unless (column = export_table.columns[col_index])
+
+          column.can_edit?
+        end
+
+        # @param table [BerkeleyLibrary::Util::ODS::XML::Table::Table] the table
+        def populate_columns!
+          export_table.columns.each_with_index do |export_column, col_index|
+            table.add_column_with_styles(
+              export_column.header,
+              column_style: column_style_for(col_index),
+              header_cell_style: header_cell_style_for(col_index)
+            )
+          end
+        end
+
+        # @param table [BerkeleyLibrary::Util::ODS::XML::Table::Table] the table
+        def populate_rows!
+          export_table.row_count.times(&method(:populate_row))
+        end
+
+        def populate_row(row_index)
+          export_row = export_table.rows[row_index]
+          row_metrics = table_metrics.row_metrics_for(row_index)
+          row_height = row_metrics.formatted_row_height
+          row = table.add_row(row_height)
+          populate_values(export_row, row_metrics, row)
+        end
+
+        def populate_values(export_row, row_metrics, row)
+          export_row.each_value.with_index do |v, col_index|
+            wrap = row_metrics.wrap?(col_index)
+            cell_style = find_or_create_cell_style(color: color_for(col_index), wrap: wrap)
+            row.set_value_at(col_index, v, cell_style)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/export/row.rb

@@ -0,0 +1,24 @@
+module BerkeleyLibrary
+  module TIND
+    module Export
+      class Row
+
+        attr_reader :columns
+        attr_reader :row_index
+
+        def initialize(columns, row_index)
+          @columns = columns
+          @row_index = row_index
+        end
+
+        def values
+          columns.map { |c| c.value_at(row_index) }
+        end
+
+        def each_value(&block)
+          columns.map { |c| c.value_at(row_index) }.each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/export/row_metrics.rb

@@ -0,0 +1,18 @@
+module BerkeleyLibrary
+  module TIND
+    module Export
+      class RowMetrics
+        attr_reader :formatted_row_height
+
+        def initialize(formatted_row_height, wrap_columns)
+          @formatted_row_height = formatted_row_height
+          @wrap_columns = wrap_columns
+        end
+
+        def wrap?(col_index)
+          @wrap_columns.include?(col_index)
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/export/table.rb

@@ -0,0 +1,175 @@
+require 'csv'
+require 'stringio'
+
+require 'marc_extensions'
+require 'berkeley_library/util/logging'
+require 'berkeley_library/tind/export/column_group_list'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      class Table
+        include BerkeleyLibrary::Logging
+
+        # ------------------------------------------------------------
+        # Accessors
+
+        attr_reader :column_groups
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        # Initializes a new Table
+        #
+        # @param exportable_only [Boolean] whether to filter out non-exportable fields
+        # @see Tags
+        def initialize(exportable_only: false)
+          @column_groups = ColumnGroupList.new(exportable_only: exportable_only)
+        end
+
+        # ------------------------------------------------------------
+        # Factory method
+
+        class << self
+          # Returns a new Table for the provided MARC records.
+          #
+          # @param records [Enumerable<MARC::Record>] the records
+          # @param freeze [Boolean] whether to freeze the table
+          # @param exportable_only [Boolean] whether to include only exportable fields
+          # @return [Table] the table
+          def from_records(records, freeze: false, exportable_only: false)
+            Table.new(exportable_only: exportable_only).tap do |table|
+              records.each { |r| table << r }
+              table.freeze if freeze
+            end
+          end
+        end
+
+        # ------------------------------------------------------------
+        # Cell accessors
+
+        def value_at(row, col)
+          return unless (column = columns[col])
+
+          column.value_at(row)
+        end
+
+        # ------------------------------------------------------------
+        # Column accessors
+
+        # The column headers
+        #
+        # @return [Array<String>] the column headers
+        def headers
+          columns.map(&:header)
+        end
+
+        # The columns
+        #
+        # @return [Array<Column>] the columns.
+        def columns
+          # NOTE: this isn't ||= because we only cache on #freeze
+          @columns || column_groups.map(&:columns).flatten
+        end
+
+        def column_count
+          columns.size
+        end
+
+        # ------------------------------------------------------------
+        # Row / MARC::Record accessors
+
+        # The rows
+        #
+        # @return [Array<Row>] the rows
+        def rows
+          # NOTE: this isn't ||= because we only cache on #freeze
+          # noinspection RubyYardReturnMatch
+          @rows || each_row.to_a
+        end
+
+        # @yieldparam row [Row] each row
+        def each_row
+          return to_enum(:each_row) unless block_given?
+
+          (0...row_count).each { |row| yield Row.new(columns, row) }
+        end
+
+        # The number of rows (records)
+        #
+        # @return [Integer] the number of rows
+        def row_count
+          marc_records.size
+        end
+
+        # The MARC records
+        #
+        # @return [Array<MARC::Record>] the records
+        def marc_records
+          @marc_records ||= []
+        end
+
+        def empty?
+          marc_records.empty?
+        end
+
+        # ------------------------------------------------------------
+        # Modifiers
+
+        # Adds the specified record
+        #
+        # @param marc_record [MARC::Record] the record to add
+        def <<(marc_record)
+          raise FrozenError, "can't modify frozen MARCTable" if frozen?
+
+          logger.warn('MARC record is not frozen') unless marc_record.frozen?
+          column_groups.add_data_fields(marc_record, marc_records.size)
+          marc_records << marc_record
+          log_record_added(marc_record)
+
+          self
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def frozen?
+          [marc_records, column_groups].all?(&:frozen?) &&
+            [@rows, @columns].all? { |d| !d.nil? && d.frozen? }
+        end
+
+        def freeze
+          [marc_records, column_groups].each(&:freeze)
+          @columns ||= columns.freeze
+          @rows ||= rows.freeze
+          self
+        end
+
+        # ------------------------------------------------------------
+        # Misc. instance methods
+
+        # TODO: move to BerkeleyLibrary::TIND::Export::CSVExporter
+        def to_csv(out = nil)
+          return write_csv(out) if out
+
+          StringIO.new.tap { |io| write_csv(io) }.string
+        end
+
+        # ------------------------------------------------------------
+        # Private methods
+
+        private
+
+        def log_record_added(marc_record)
+          return logger.debug("Added record no. #{marc_record.record_id}: #{row_count} records total") if marc_record
+        end
+
+        def write_csv(out)
+          csv = out.respond_to?(:write) ? CSV.new(out) : CSV.open(out, 'wb')
+          csv << headers
+          each_row { |row| csv << row.values }
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/export/table_metrics.rb

@@ -0,0 +1,116 @@
+require 'berkeley_library/util/logging'
+require 'berkeley_library/tind/export/row_metrics'
+require 'berkeley_library/tind/export/config'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      class TableMetrics
+        include BerkeleyLibrary::Logging
+        include Config
+
+        # @return [Table] the table
+        attr_reader :table
+
+        # Initializes a new set of metrics for the specified table.
+        #
+        # @param table [Table] the table
+        def initialize(table)
+          @table = table
+        end
+
+        def formatted_width(col_index)
+          inches_numeric = numeric_column_width(col_index)
+          format_inches(inches_numeric)
+        end
+
+        def row_metrics_for(row_index)
+          @metrics_by_row ||= []
+          @metrics_by_row[row_index] ||= calc_row_metrics(row_index)
+        end
+
+        # ------------------------------------------------------------
+        # Private methods
+
+        private
+
+        # ------------------------------
+        # Private accessors
+
+        def inch_format
+          @inch_format ||= "%0.#{format_digits}fin"
+        end
+
+        def numeric_column_width(col_index)
+          @numeric_column_widths ||= []
+          @numeric_column_widths[col_index] ||= calc_max_width(col_index)
+        end
+
+        def cell_widths_for_column(col_index)
+          @cell_widths_by_column ||= []
+          @cell_widths_by_column[col_index] ||= calc_cell_widths(col_index)
+        end
+
+        # ------------------------------
+        # Private utility methods
+
+        def calc_max_width(col_index)
+          header = table.columns[col_index].header
+          w_header = ColumnWidthCalculator.width_inches(header)
+          w_cell_max = cell_widths_for_column(col_index).max
+          w_max_actual = [w_header, w_cell_max].max
+          w_max_rounded = (w_max_actual / w_incr_in).ceil * w_incr_in
+          [w_max_rounded, max_col_width_in].min
+        end
+
+        def calc_cell_widths(col_index)
+          column = table.columns[col_index]
+          column.each_value.map { |v| ColumnWidthCalculator.width_inches(v) }
+        end
+
+        def format_inches(inches_numeric)
+          format(inch_format, inches_numeric)
+        end
+
+        def calc_row_metrics(row_index)
+          columns_to_wrap = Set.new
+          max_wrapped_lines = 1
+
+          table.column_count.times do |col_index|
+            wrapped_lines = wrapped_lines_for_cell(row_index, col_index)
+            max_wrapped_lines = [wrapped_lines, max_wrapped_lines].max
+            columns_to_wrap << col_index if wrapped_lines > 1
+          end
+
+          formatted_height = format_row_height(max_wrapped_lines)
+          RowMetrics.new(formatted_height, columns_to_wrap)
+        end
+
+        # TODO: something smarter, maybe guess at break locations?
+        def wrapped_lines_for_cell(row_index, col_index)
+          w_col = numeric_column_width(col_index)
+          w_cell = numeric_cell_width(row_index, col_index)
+          (w_cell / w_col).ceil
+        end
+
+        def numeric_cell_width(row_index, col_index)
+          cell_widths_by_row = cell_widths_for_column(col_index)
+          cell_widths_by_row[row_index] || 0
+        end
+
+        def numeric_line_height_inches
+          @numeric_line_height_inches ||= begin
+            h_exact_pts = font_size_pt * line_height_em
+            h_rounded_pts = (h_exact_pts / h_incr_pt).ceil * h_incr_pt
+            h_rounded_pts / 72.0
+          end
+        end
+
+        def format_row_height(lines)
+          @formatted_row_heights ||= []
+          @formatted_row_heights[lines] ||= format_inches(lines * numeric_line_height_inches)
+        end
+      end
+    end
+  end
+end