berkeley_library-tind 0.4.0

data/lib/berkeley_library/tind/export.rb

@@ -0,0 +1 @@
+Dir.glob(File.expand_path('export/*.rb', __dir__)).sort.each(&method(:require))

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

@@ -0,0 +1,54 @@
+require 'marc_extensions'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      class Column
+
+        # @return [ColumnGroup] the group containing this column
+        attr_reader :column_group
+
+        # @return [Integer] the index of this column in the group
+        attr_reader :col_in_group
+
+        # Initializes a new column
+        #
+        # @param column_group [ColumnGroup] the group containing this column
+        # @param col_in_group [Integer] the index of this column in the group
+        def initialize(column_group, col_in_group)
+          @column_group = column_group
+          @col_in_group = col_in_group
+        end
+
+        def header
+          # NOTE: that TIND "-#" suffixes must be unique by tag, not tag + ind1 + ind2
+          @header ||= "#{column_group.prefix}#{subfield_code}-#{1 + column_group.index_in_tag}"
+        end
+
+        def subfield_code
+          @subfield_code ||= column_group.subfield_codes[col_in_group]
+        end
+
+        def value_at(row)
+          column_group.value_at(row, col_in_group)
+        end
+
+        def can_edit?
+          @can_edit ||= Filter.can_edit?(
+            column_group.tag,
+            column_group.ind1,
+            column_group.ind2,
+            subfield_code
+          )
+        end
+
+        def each_value(include_header: false)
+          return to_enum(:each_value, include_header: include_header) unless block_given?
+
+          yield header if include_header
+          column_group.row_count.times { |row| yield value_at(row) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+require 'berkeley_library/tind/export/column'
+require 'berkeley_library/util/arrays'
+require 'berkeley_library/util/strings'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+
+      # A group of columns representing the subfields of a particular
+      # data field.
+      class ColumnGroup
+        include BerkeleyLibrary::Util::Arrays
+
+        # ------------------------------------------------------------
+        # Constants
+
+        # Indicators SHOULD NOT be capital letters, but TIND internal fields
+        # don't respect that. Thus the /i flag.
+        INDICATOR_RE = /^[0-9a-z ]$/i.freeze
+
+        SUBFIELD_CODE_RE = /^[0-9a-z]$/.freeze
+
+        # ------------------------------------------------------------
+        # Accessors
+
+        attr_reader :tag, :index_in_tag, :ind1, :ind2, :subfield_codes
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(tag, index_in_tag, ind1, ind2, subfield_codes)
+          @tag, @ind1, @ind2 = valid_tag_and_indicators(tag, ind1, ind2)
+          @subfield_codes = valid_subfield_codes(subfield_codes).dup.freeze
+          @index_in_tag = index_in_tag
+        end
+
+        # ------------------------------------------------------------
+        # Class methods
+
+        class << self
+
+          def prefix_for(data_field)
+            format_prefix(data_field.tag, data_field.indicator1, data_field.indicator2)
+          end
+
+          def format_indicator(ind)
+            ind == ' ' ? '_' : ind
+          end
+
+          def format_prefix(tag, ind1, ind2)
+            [tag, format_indicator(ind1), format_indicator(ind2)].join
+          end
+        end
+
+        # ------------------------------------------------------------
+        # Instance methods
+
+        def prefix
+          ColumnGroup.format_prefix(tag, ind1, ind2)
+        end
+
+        def maybe_add_at(row, data_field)
+          warn "Data field at row #{row} is not frozen: #{data_field}" unless data_field.subfields.frozen?
+          # set nil explicitly so row_count etc. are correct
+          return (data_fields[row] = nil) unless can_add?(data_field)
+
+          @subfield_codes = merge(subfield_codes, data_field.subfield_codes)
+          data_fields[row] = data_field
+        end
+
+        def value_at(row, col)
+          return unless (data_field = data_fields[row])
+          return unless (subfield_indices = subfield_indices_for(row))
+          return unless (subfield_index = subfield_indices[col])
+          return unless (subfield = data_field.subfields[subfield_index])
+
+          subfield.value
+        end
+
+        def columns
+          @columns ||= (0...subfield_codes.length).map { |col| Column.new(self, col) }
+        end
+
+        def row_count
+          data_fields.size
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def to_s
+          "ColumnGroup #{tag}-#{index_in_tag}:" + [prefix, subfield_codes.join].join
+        end
+
+        # ------------------------------------------------------------
+        # Private methods
+
+        private
+
+        def valid_tag_and_indicators(tag, ind1, ind2)
+          raise ArgumentError, "#{tag}#{ind1}#{ind2}: not a valid tag" unless tag.size == 3 && BerkeleyLibrary::Util::Strings.ascii_numeric?(tag)
+          raise ArgumentError, "#{tag}#{ind1}#{ind2}: not a valid indicator: #{ind1.inspect}" unless ind1 =~ INDICATOR_RE
+          raise ArgumentError, "#{tag}#{ind1}#{ind2}: not a valid indicator: #{ind2.inspect}" unless ind2 =~ INDICATOR_RE
+
+          [tag, ind1, ind2]
+        end
+
+        def valid_subfield_codes(subfield_codes)
+          subfield_codes.tap do |scc|
+            raise ArgumentError, "Invalid subfield codes: #{scc.inspect}" unless scc.all? { |c| c =~ SUBFIELD_CODE_RE }
+          end
+        end
+
+        def can_add?(data_field)
+          data_field.tag == tag &&
+            data_field.indicator1 == ind1 &&
+            data_field.indicator2 == ind2
+        end
+
+        def subfield_indices_for(row)
+          return cached_subfield_indices[row] if row < cached_subfield_indices.size
+          return unless (data_field = data_fields[row])
+
+          cached_subfield_indices[row] = find_subfield_indices(data_field)
+        end
+
+        def cached_subfield_indices
+          @cached_subfield_indices ||= []
+        end
+
+        def find_subfield_indices(data_field)
+          return unless can_add?(data_field)
+
+          df_index_to_cg_index = find_indices(in_array: subfield_codes, for_array: data_field.subfield_codes)
+          invert(df_index_to_cg_index)
+        end
+
+        def data_fields
+          @data_fields ||= []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+require 'berkeley_library/tind/export/filter'
+require 'berkeley_library/tind/export/column_group'
+require 'berkeley_library/tind/export/column'
+require 'berkeley_library/tind/export/export_exception'
+require 'berkeley_library/tind/export/row'
+require 'berkeley_library/util/arrays'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      class ColumnGroupList
+        include Enumerable
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        def initialize(exportable_only: false)
+          @exportable_only = exportable_only
+        end
+
+        # ------------------------------------------------------------
+        # Accessors
+
+        def exportable_only?
+          @exportable_only
+        end
+
+        # ------------------------------------------------------------
+        # Misc. instance methods
+
+        def all_groups
+          # NOTE: this isn't ||= because we only cache on #freeze
+          @all_groups || begin
+            all_tags = column_groups_by_tag.keys.sort
+            all_tags.each_with_object([]) do |tag, groups|
+              tag_column_groups = column_groups_by_tag[tag]
+              groups.concat(tag_column_groups)
+            end
+          end
+        end
+
+        def add_data_fields(marc_record, row)
+          # TODO: what about control fields?
+          marc_record.data_fields_by_tag.each do |tag, data_fields|
+            next unless can_export_tag(tag)
+            next if data_fields.empty?
+
+            add_fields_at(data_fields, row)
+          end
+        rescue StandardError => e
+          raise Export::ExportException, "Error adding MARC record #{marc_record.record_id} at row #{row}: #{e.message}"
+        end
+
+        # ------------------------------------------------------------
+        # Enumerable
+
+        def each(&block)
+          all_groups.each(&block)
+        end
+
+        # ------------------------------------------------------------
+        # Object overrides
+
+        def freeze
+          column_groups_by_tag.each_value(&:freeze)
+          column_groups_by_tag.freeze
+          @all_groups ||= all_groups.freeze
+          self
+        end
+
+        def frozen?
+          column_groups_by_tag.frozen? &&
+            @all_groups && @all_groups.frozen?
+        end
+
+        # ------------------------------------------------------------
+        # Private methods
+
+        private
+
+        def column_groups_by_tag
+          @column_groups_by_tag ||= {}
+        end
+
+        def add_fields_at(data_fields, row)
+          tag = data_fields[0].tag.freeze
+          tag_column_groups = (column_groups_by_tag[tag] ||= [])
+
+          data_fields.inject(0) do |offset, df|
+            next offset unless can_export_df(df)
+
+            1 + add_data_field(df, row, tag_column_groups, at_or_after: offset)
+          end
+        end
+
+        def add_data_field(df, row, tag_column_groups, at_or_after: 0)
+          added_at = added_at_index(df, row, tag_column_groups, at_or_after)
+          return added_at if added_at
+
+          new_group = ColumnGroup.new(df.tag, tag_column_groups.size, df.indicator1, df.indicator2, exportable_subfield_codes(df)).tap do |cg|
+            raise Export::ExportException, "Unexpected failure to add #{df} to #{cg}" unless cg.maybe_add_at(row, df)
+          end
+          tag_column_groups << new_group
+          tag_column_groups.size - 1
+        end
+
+        def added_at_index(df, row, tag_column_groups, at_or_after)
+          BerkeleyLibrary::Util::Arrays.find_index(in_array: tag_column_groups, start_index: at_or_after) { |cg| cg.maybe_add_at(row, df) }
+        end
+
+        def can_export_tag(tag)
+          return true unless exportable_only?
+
+          Filter.can_export_tag?(tag)
+        end
+
+        def can_export_df(df)
+          return true unless exportable_only?
+
+          Filter.can_export_data_field?(df)
+        end
+
+        def exportable_subfield_codes(df)
+          return df.subfield_codes unless exportable_only?
+
+          Filter.exportable_subfield_codes(df)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'berkeley_library/tind/export/config'
+
+module BerkeleyLibrary
+  module TIND
+    module Export
+      # Calculates approximate column widths for cell values, based on
+      # Arial average character widths ()in units of 1/1000 point size) per
+      # {https://www.math.utah.edu/~beebe/fonts/afm-widths.html this table}.
+      # (LibreOffice default is Liberation Sans, which should match Arial.)
+      #
+      # CJK and fullwidth characters will probably be mapped to another font,
+      # but it's probably going to be roughly square.
+      #
+      # Non-Western, non-CJK characters will *hopefully* not be much wider
+      # than their Western counterparts.
+      module ColumnWidthCalculator
+        include Config
+
+        WIDTH_UNIT = 1000.0
+
+        WIDTH_LOWER = 489.46
+
+        WIDTH_UPPER = 677.42
+
+        WIDTH_DIGIT = 556.0
+
+        # Measured empirically in LibreOffice 6.4.7.2
+        WIDTH_CJK = 970.0
+
+        WIDTHS = {
+          /[\u4e00-\u9fff]/ => WIDTH_CJK, # CJK (excluding half-width forms)
+          /[\uff01-\uff65\uffe0-\uffee]/ => WIDTH_CJK, # Fullwidth forms
+          /[[:digit:]]/ => WIDTH_DIGIT,
+          /[[:upper:]]/ => WIDTH_UPPER,
+          /[[:lower:]]/ => WIDTH_LOWER,
+          /[[:space:]]/ => 2 * WIDTH_LOWER / 3 # empirical
+        }.freeze
+
+        # See {WIDTHS}
+        WIDTH_DEFAULT = WIDTH_DIGIT # Fallback to digit width for other characters
+
+        def width_ps_units(str)
+          return 0 if str.nil? || str.empty?
+
+          chars = str.unicode_normalize.chars
+          chars.inject(0) { |total, c| total + width_for_char(c) }
+        end
+
+        def width_points(str, font_size_points = font_size_pt)
+          width_per_point(str) * font_size_points
+        end
+
+        def width_inches(str, font_size_points = font_size_pt)
+          return 0 if str.nil? || str.empty?
+
+          width_points(str, font_size_points) / 72.0
+        end
+
+        private
+
+        def width_per_point(str)
+          width_ps_units(str) / WIDTH_UNIT
+        end
+
+        def width_for_char(c)
+          WIDTHS.each { |re, w| return w if c =~ re }
+          WIDTH_DEFAULT
+        end
+
+        class << self
+          include ColumnWidthCalculator
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+module BerkeleyLibrary
+  module TIND
+    module Export
+      module Config
+
+        # Font size in points
+        FONT_SIZE_DEFAULT = 10.0
+
+        # Round column widths up to nearest eighth inch
+        WIDTH_INCREMENT_DEFAULT_INCHES = '1/8'.to_r
+
+        # Round row heights up to nearest 2 points
+        HEIGHT_INCREMENT_DEFAULT_POINTS = 2
+
+        # Max column width before wrapping
+        MAX_COLUMN_WIDTH_INCHES = 5.0
+
+        # Decimal places for formatting
+        FORMAT_DIGITS_DEFAULT = 3
+
+        # Line height as multiple of font size
+        LINE_HEIGHT_DEFAULT_EM = '4/3'.to_r
+
+        # @return [Numeric] the font size in points
+        def font_size_pt
+          Config.font_size_pt
+        end
+
+        # @return [Numeric] the max column width in inches
+        def max_col_width_in
+          Config.max_col_width_in
+        end
+
+        # @return [Numeric] the width rounding increment in inches
+        def w_incr_in
+          Config.w_incr_in
+        end
+
+        # @return [Numeric] the height rounding increment in points
+        def h_incr_pt
+          Config.h_incr_pt
+        end
+
+        # @return [Numeric] the line height in ems (multiples of the font point size)
+        def line_height_em
+          Config.line_height_em
+        end
+
+        # @return [Integer] the number of digits to use when formatting values
+        def format_digits
+          Config.format_digits
+        end
+
+        # noinspection RubyYardReturnMatch
+        class << self
+
+          # @return [Numeric] the font size in points
+          def font_size_pt
+            @font_size_pt ||= ensure_positive_numeric(ENV['ODS_FONT_SIZE_DEFAULT'] || Config::FONT_SIZE_DEFAULT)
+          end
+
+          def font_size_pt=(value)
+            @font_size_pt = ensure_positive_numeric(value)
+          end
+
+          # @return [Numeric] the max column width in inches
+          def max_col_width_in
+            @max_col_width_in ||= ensure_positive_numeric(ENV['ODS_MAX_COLUMN_WIDTH_INCHES'] || Config::MAX_COLUMN_WIDTH_INCHES)
+          end
+
+          def max_col_width_in=(value)
+            @max_col_width_in = ensure_positive_numeric(value)
+          end
+
+          # @return [Numeric] the width rounding increment in inches
+          def w_incr_in
+            @w_incr_in ||= ensure_positive_numeric(ENV['ODS_WIDTH_INCREMENT_DEFAULT_INCHES'] || Config::WIDTH_INCREMENT_DEFAULT_INCHES)
+          end
+
+          def w_incr_in=(value)
+            @w_incr_in = ensure_positive_numeric(value)
+          end
+
+          # @return [Numeric] the height rounding increment in points
+          def h_incr_pt
+            @h_incr_pt ||= ensure_positive_numeric(ENV['ODS_HEIGHT_INCREMENT_DEFAULT_POINTS'] || Config::HEIGHT_INCREMENT_DEFAULT_POINTS)
+          end
+
+          def h_incr_pt=(value)
+            @h_incr_pt = ensure_positive_numeric(value)
+          end
+
+          # @return [Numeric] the line height in ems (multiples of the font point size)
+          def line_height_em
+            @line_height_em ||= ensure_positive_numeric(ENV['ODS_LINE_HEIGHT_DEFAULT_EM'] || Config::LINE_HEIGHT_DEFAULT_EM)
+          end
+
+          def line_height_em=(value)
+            @line_height_em = ensure_positive_numeric(value)
+          end
+
+          # @return [Integer] the number of digits to use when formatting values
+          def format_digits
+            @format_digits ||= ensure_positive_int(ENV['ODS_FORMAT_DIGITS_DEFAULT'] || Config::FORMAT_DIGITS_DEFAULT)
+          end
+
+          def format_digits=(value)
+            @format_digits = ensure_positive_int(value)
+          end
+
+          private
+
+          # @param v [Object] a value
+          # @return [Numeric] a numeric value, or nil if the value is not numeric
+          def ensure_positive_numeric(v)
+            v_n = ensure_numeric(v)
+            return v_n if v_n > 0
+
+            raise ArgumentError, "Value must be positive: #{v_n}"
+          end
+
+          def ensure_numeric(v)
+            return v if v.is_a?(Numeric)
+
+            v_str = v.to_s
+            return v_str.to_r if v_str.include?('/')
+            return v_str.to_f if v_str.include?('.')
+            return Integer(v_str) if v_str =~ /(?:0x\h+|\d+)/
+
+            raise ArgumentError, "Can't parse #{v.inspect} as a numeric value"
+          end
+
+          # @param v [Object] a value
+          # @return [Integer]
+          def ensure_positive_int(v)
+            v_i = ensure_int(v)
+            return v_i if v_i > 0
+
+            raise ArgumentError, "Value must be positive: #{v_i}"
+          end
+
+          def ensure_int(v)
+            return v if v.is_a?(Integer)
+
+            v_str = v.to_s
+            return Integer(v_str) if v_str =~ /(?:0x\h+|\d+)/
+
+            raise ArgumentError, "Can't parse #{v.inspect} as an integer value"
+          end
+        end
+      end
+    end
+  end
+end