tabulard 0.2.0

data/lib/sheetah/messaging/messages/must_be_date.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../message_variant"
+
+module Sheetah
+  module Messaging
+    module Messages
+      class MustBeDate < MessageVariant
+        CODE = "must_be_date"
+
+        def_validator do
+          cell
+
+          def validate_code_data(message)
+            message.code_data in { format: String }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/messages/must_be_email.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../message_variant"
+
+module Sheetah
+  module Messaging
+    module Messages
+      class MustBeEmail < MessageVariant
+        CODE = "must_be_email"
+
+        def_validator do
+          cell
+
+          def validate_code_data(message)
+            message.code_data in { value: String }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/messages/must_be_string.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../message_variant"
+
+module Sheetah
+  module Messaging
+    module Messages
+      class MustBeString < MessageVariant
+        CODE = "must_be_string"
+
+        def_validator do
+          cell
+          nil_code_data
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/messages/must_exist.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../message_variant"
+
+module Sheetah
+  module Messaging
+    module Messages
+      class MustExist < MessageVariant
+        CODE = "must_exist"
+
+        def_validator do
+          cell
+          nil_code_data
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/messages/sheet_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../message_variant"
+
+module Sheetah
+  module Messaging
+    module Messages
+      class SheetError < MessageVariant
+        CODE = "sheet_error"
+
+        def_validator do
+          sheet
+          nil_code_data
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/messenger.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module Sheetah
+  module Messaging
+    class Messenger
+      def initialize(
+        scope: SCOPES::SHEET,
+        scope_data: nil,
+        validate_messages: Messaging.config.validate_messages
+      )
+        @scope = scope.freeze
+        @scope_data = scope_data.freeze
+        @messages = []
+        @validate_messages = validate_messages
+      end
+
+      attr_reader :scope, :scope_data, :messages, :validate_messages
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          scope == other.scope &&
+          scope_data == other.scope_data &&
+          messages == other.messages &&
+          validate_messages == other.validate_messages
+      end
+
+      def dup
+        self.class.new(
+          scope: @scope,
+          scope_data: @scope_data,
+          validate_messages: @validate_messages
+        )
+      end
+
+      def scoping!(scope, scope_data, &block)
+        scope      = scope.freeze
+        scope_data = scope_data.freeze
+
+        if block
+          replace_scoping_block(scope, scope_data, &block)
+        else
+          replace_scoping_noblock(scope, scope_data)
+        end
+      end
+
+      def scoping(...)
+        dup.scoping!(...)
+      end
+
+      def scope_row!(row, &block)
+        scope = case @scope
+                when SCOPES::COL, SCOPES::CELL
+                  SCOPES::CELL
+                else
+                  SCOPES::ROW
+                end
+
+        scope_data = @scope_data.dup || {}
+        scope_data[:row] = row
+
+        scoping!(scope, scope_data, &block)
+      end
+
+      def scope_col!(col, &block)
+        scope = case @scope
+                when SCOPES::ROW, SCOPES::CELL
+                  SCOPES::CELL
+                else
+                  SCOPES::COL
+                end
+
+        scope_data = @scope_data.dup || {}
+        scope_data[:col] = col
+
+        scoping!(scope, scope_data, &block)
+      end
+
+      def scope_row(...)
+        dup.scope_row!(...)
+      end
+
+      def scope_col(...)
+        dup.scope_col!(...)
+      end
+
+      def warn(message)
+        add(message, severity: SEVERITIES::WARN)
+      end
+
+      def error(message)
+        add(message, severity: SEVERITIES::ERROR)
+      end
+
+      private
+
+      def add(message, severity:)
+        message.scope = @scope
+        message.scope_data = @scope_data
+        message.severity = severity
+
+        message.validate if @validate_messages
+
+        messages << message
+
+        self
+      end
+
+      def replace_scoping_noblock(new_scope, new_scope_data)
+        @scope      = new_scope
+        @scope_data = new_scope_data
+
+        self
+      end
+
+      def replace_scoping_block(new_scope, new_scope_data)
+        prev_scope      = @scope
+        prev_scope_data = @scope_data
+
+        @scope      = new_scope
+        @scope_data = new_scope_data
+
+        begin
+          yield self
+        ensure
+          @scope = prev_scope
+          @scope_data = prev_scope_data
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/validations/base_validator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "dsl"
+require_relative "invalid_message"
+
+module Sheetah
+  module Messaging
+    module Validations
+      class BaseValidator
+        extend DSL
+
+        def validate(message)
+          errors = []
+
+          errors << "code"       unless validate_code(message)
+          errors << "code_data"  unless validate_code_data(message)
+          errors << "scope"      unless validate_scope(message)
+          errors << "scope_data" unless validate_scope_data(message)
+
+          return if errors.empty?
+
+          raise InvalidMessage, "#{errors.join(", ")} <#{message.class}>#{message.to_h}"
+        end
+
+        def validate_code(_message)
+          true
+        end
+
+        def validate_code_data(_message)
+          true
+        end
+
+        def validate_scope(_message)
+          true
+        end
+
+        def validate_scope_data(_message)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/validations/dsl.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "mixins"
+
+module Sheetah
+  module Messaging
+    module Validations
+      module DSL
+        def cell
+          include Mixins::CellValidations
+        end
+
+        def col
+          include Mixins::ColValidations
+        end
+
+        def row
+          include Mixins::RowValidations
+        end
+
+        def sheet
+          include Mixins::SheetValidations
+        end
+
+        def nil_code_data
+          include Mixins::NilCodeData
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/validations/invalid_message.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../../errors/error"
+
+module Sheetah
+  module Messaging
+    module Validations
+      class InvalidMessage < Errors::Error
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/validations/mixins.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Sheetah
+  module Messaging
+    module Validations
+      module Mixins
+        module CellValidations
+          def validate_scope(message)
+            message.scope == SCOPES::CELL
+          end
+
+          def validate_scope_data(message)
+            message.scope_data in { col: String, row: Integer }
+          end
+        end
+
+        module ColValidations
+          def validate_scope(message)
+            message.scope == SCOPES::COL
+          end
+
+          def validate_scope_data(message)
+            message.scope_data in { col: String }
+          end
+        end
+
+        module RowValidations
+          def validate_scope(message)
+            message.scope == SCOPES::ROW
+          end
+
+          def validate_scope_data(message)
+            message.scope_data in { row: Integer }
+          end
+        end
+
+        module SheetValidations
+          def validate_scope(message)
+            message.scope == SCOPES::SHEET
+          end
+
+          def validate_scope_data(message)
+            message.scope_data.nil?
+          end
+        end
+
+        module NilCodeData
+          def validate_code_data(message)
+            message.code_data.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sheetah/messaging/validations.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "validations/base_validator"
+
+module Sheetah
+  module Messaging
+    module Validations
+      module ClassMethods
+        def def_validator(base: validator&.class || BaseValidator, &block)
+          @validator = Class.new(base, &block).new.freeze
+        end
+
+        def validator
+          if defined?(@validator)
+            @validator
+          elsif superclass.respond_to?(:validator)
+            superclass.validator
+          end
+        end
+
+        def validate(message)
+          validator&.validate(message)
+        end
+      end
+
+      def self.included(message_class)
+        message_class.extend(ClassMethods)
+      end
+
+      def validate
+        self.class.validate(self)
+      end
+    end
+  end
+end

data/lib/sheetah/messaging.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sheetah
+  module Messaging
+    require_relative "messaging/config"
+    require_relative "messaging/constants"
+    require_relative "messaging/message"
+    require_relative "messaging/messenger"
+
+    class << self
+      attr_accessor :config
+
+      def configure
+        config = self.config.dup
+        yield config
+        self.config = config.freeze
+      end
+    end
+
+    self.config = Config.new.freeze
+  end
+end

data/lib/sheetah/row_processor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "row_processor_result"
+require_relative "row_value_builder"
+
+module Sheetah
+  class RowProcessor
+    def initialize(headers:, messenger:)
+      @headers = headers
+      @messenger = messenger
+    end
+
+    def call(row)
+      messenger = @messenger.dup
+
+      builder = RowValueBuilder.new(messenger)
+
+      messenger.scope_row!(row.row) do
+        @headers.each do |header|
+          cell = row.value[header.row_value_index]
+
+          messenger.scope_col!(cell.col) do
+            builder.add(header.column, cell.value)
+          end
+        end
+      end
+
+      build_result(row, builder, messenger)
+    end
+
+    private
+
+    def build_result(row, builder, messenger)
+      RowProcessorResult.new(
+        row: row.row,
+        result: builder.result,
+        messages: messenger.messages
+      )
+    end
+  end
+end

data/lib/sheetah/row_processor_result.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sheetah
+  class RowProcessorResult
+    def initialize(row:, result:, messages: [])
+      @row = row
+      @result = result
+      @messages = messages
+    end
+
+    attr_reader :row, :result, :messages
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        row == other.row &&
+        result == other.result &&
+        messages == other.messages
+    end
+  end
+end

data/lib/sheetah/row_value_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "utils/monadic_result"
+
+module Sheetah
+  class RowValueBuilder
+    include Utils::MonadicResult
+
+    def initialize(messenger)
+      @messenger  = messenger
+      @data       = {}
+      @composites = Set.new
+      @failure    = false
+    end
+
+    def add(column, value)
+      key = column.key
+      type = column.type
+      index = column.index
+
+      result = type.scalar(index, value, @messenger)
+
+      result.bind do |scalar|
+        if type.composite?
+          @composites << [key, type]
+          @data[key] ||= []
+          @data[key][index] = scalar
+        else
+          @data[key] = scalar
+        end
+      end
+
+      result.or { @failure = true }
+
+      result
+    end
+
+    def result
+      return Failure() if @failure
+
+      Do() do
+        @composites.each do |key, type|
+          value = type.composite(@data[key], @messenger).unwrap
+
+          @data[key] = value
+        end
+
+        Success(@data)
+      end
+    end
+  end
+end

data/lib/sheetah/sheet/col_converter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Sheetah
+  module Sheet
+    class ColConverter
+      CHARSET      = ("A".."Z").to_a.freeze
+      CHARSET_SIZE = CHARSET.size
+      CHAR_TO_INT  = CHARSET.map.with_index(1).to_h.freeze
+      INT_TO_CHAR  = CHAR_TO_INT.invert.freeze
+
+      def col2int(col)
+        raise ArgumentError unless col.is_a?(String) && !col.empty?
+
+        int = 0
+
+        col.each_char.reverse_each.with_index do |char, pow|
+          int += char2int(char) * (CHARSET_SIZE**pow)
+        end
+
+        int
+      end
+
+      def int2col(int)
+        raise ArgumentError unless int.is_a?(Integer) && int.positive?
+
+        x = int
+        y = CHARSET_SIZE
+        col = +""
+
+        until x.zero?
+          q, r = x.divmod(y)
+
+          if r.zero?
+            q -= 1
+            r = y
+          end
+
+          x = q
+
+          col << int2char(r)
+        end
+
+        col.reverse!
+        col.freeze
+      end
+
+      private
+
+      def char2int(char)
+        CHAR_TO_INT[char] || raise(ArgumentError, char.inspect)
+      end
+
+      def int2char(int)
+        INT_TO_CHAR[int] || raise(ArgumentError, int.inspect)
+      end
+    end
+
+    private_constant :ColConverter
+
+    COL_CONVERTER = ColConverter.new.freeze
+  end
+end