acts_as_table 0.0.1

data/lib/acts_as_table/path.rb

@@ -0,0 +1,157 @@
+module ActsAsTable
+  # ActsAsTable path object.
+  #
+  # @!attribute [r] klass
+  #   Returns the class for this ActsAsTable path object.
+  #
+  #   @return [Class]
+  # @!attribute [r] parent
+  #   Returns the parent of this ActsAsTable path object or `nil`, if this ActsAsTable path object is the start.
+  #
+  #   @return [ActsAsTable::Path, nil]
+  # @!attribute [r] options
+  #   Returns the options for this ActsAsTable path object.
+  #
+  #   @return [Hash<Symbol, Object>]
+  # @!method belongs_to(method_name, **options)
+  #   Reflect on a `:belongs_to` association using this ActsAsTable path object.
+  #
+  #   @param [#to_s] method_name
+  #   @param [Hash<Symbol, Object>] options
+  #   @option options [Object] :data
+  #   @return [ActsAsTable::Path]
+  #   @raise [ArgumentError] If the association is invalid.
+  # @!method has_one(method_name, **options)
+  #   Reflect on a `:has_one` association using this ActsAsTable path object.
+  #
+  #   @param [#to_s] method_name
+  #   @param [Hash<Symbol, Object>] options
+  #   @option options [Object] :data
+  #   @return [ActsAsTable::Path]
+  #   @raise [ArgumentError] If the association is invalid.
+  # @!method has_many(method_name, index, **options)
+  #   Reflect on a `:has_many` association using this ActsAsTable path object.
+  #
+  #   @param [#to_s] method_name
+  #   @param [Integer] index
+  #   @param [Hash<Symbol, Object>] options
+  #   @option options [Object] :data
+  #   @return [ActsAsTable::Path]
+  #   @raise [ArgumentError] If the association is invalid.
+  # @!method has_and_belongs_to_many(method_name, index, **options)
+  #   Reflect on a `:has_and_belongs_to_many` association using this ActsAsTable path object.
+  #
+  #   @param [#to_s] method_name
+  #   @param [Integer] index
+  #   @param [Hash<Symbol, Object>] options
+  #   @option options [Object] :data
+  #   @return [ActsAsTable::Path]
+  #   @raise [ArgumentError] If the association is invalid.
+  class Path
+    include ::Enumerable
+
+    attr_reader :klass, :parent, :options
+
+    # Returns a new ActsAsTable path object for the given class, parent (optional) and options.
+    #
+    # @param [Class] klass
+    # @param [ActsAsTable::Path, nil] parent
+    # @param [Hash<Symbol, Object>] options
+    # @option options [#to_s] :macro
+    # @option options [#to_s] :method_name
+    # @option options [Integer, nil] :index
+    # @option options [Object] :data
+    # @return [ActsAsTable::Path]
+    def initialize(klass, parent = nil, **options)
+      options.assert_valid_keys(:data, :index, :macro, :method_name)
+
+      @klass, @parent, @options = klass, parent, options.dup
+    end
+
+    # Enumerate this ActsAsTable path object, its parent, its grandparent, etc.
+    #
+    # @yieldparam [ActsAsTable::Path] path
+    # @yieldreturn [void]
+    # @return [Enumerable<ActsAsTable::Path>]
+    def each(&block)
+      ::Enumerator.new { |enumerator|
+        # @return [ActsAsTable::Path, nil]
+        path = self
+
+        until path.nil?
+          enumerator << path
+
+          # @return [ActsAsTable::Path, nil]
+          path = path.parent
+        end
+      }.each(&block)
+    end
+
+    # Returns the symbolic name for this ActsAsTable path object.
+    #
+    # @return [Symbol]
+    def to_sym
+      if self.parent.nil?
+        nil
+      else
+        self.inject([]) { |acc, path|
+          acc << path.options.values_at(:method_name, :index)
+          acc
+        }.reverse.flatten(1).compact.collect(&:to_s).join('_').to_sym
+      end
+    end
+
+    # Terminates this ActsAsTable path object and returns its symbolic name.
+    #
+    # @param [#to_s] method_name
+    # @return [Symbol]
+    def attribute(method_name)
+      unless [:"#{method_name}", :"#{method_name}="].all? { |sym| @klass.instance_methods.include?(sym) } || @klass.column_names.include?(method_name.to_s)
+        raise ::ArgumentError.new("method_name - #{method_name.inspect} is invalid")
+      end
+
+      self.inject([[method_name]]) { |acc, path|
+        acc << path.options.values_at(:method_name, :index)
+        acc
+      }.reverse.flatten(1).compact.collect(&:to_s).join('_').to_sym
+    end
+
+    %i(belongs_to has_one).each do |macro|
+      define_method(macro) do |method_name, **options|
+        options.assert_valid_keys(:data)
+
+        # @return [ActiveRecord::Reflection::MacroReflection]
+        reflection = @klass.reflect_on_association(method_name)
+
+        if reflection.nil? || (reflection.macro != macro)
+          raise ::ArgumentError.new("method_name - #{method_name.inspect} is invalid")
+        end
+
+        self.class.new(reflection.klass, self, **options.merge({
+          macro: macro,
+          method_name: method_name,
+          index: nil,
+        }))
+      end
+    end
+
+    %i(has_many has_and_belongs_to_many).each do |macro|
+      define_method(macro) do |method_name, index, **options|
+        options.assert_valid_keys(:data)
+
+        # @return [ActiveRecord::Reflection::MacroReflection]
+        reflection = @klass.reflect_on_association(method_name)
+
+        if reflection.nil? || (reflection.macro != macro)
+          raise ::ArgumentError.new("method_name - #{method_name.inspect} is invalid")
+        end
+
+        self.class.new(reflection.klass, self, **options.merge({
+          macro: macro,
+          method_name: method_name,
+          index: index,
+        }))
+      end
+    end
+  end
+end

data/lib/acts_as_table/reader.rb

@@ -0,0 +1,149 @@
+module ActsAsTable
+  # ActsAsTable reader object.
+  #
+  # @!attribute [r] row_model
+  #   Returns the ActsAsTable row model for this ActsAsTable reader object.
+  #
+  #   @return [ActsAsTable::RowModel]
+  # @!attribute [r] input
+  #   Returns the input stream for this ActsAsTable reader object.
+  #
+  #   @return [IO]
+  # @!attribute [r] options
+  #   Returns the options for this ActsAsTable reader object.
+  #
+  #   @return [Hash<Symbol, Object>]
+  class Reader
+    # Returns a new ActsAsTable reader object based on a symbolic name using the given arguments.
+    #
+    # @param [Symbol] format
+    # @param [Array<Object>] args
+    # @yieldparam [ActsAsTable::Reader] reader
+    # @yieldreturn [void]
+    # @return [ActsAsTable::Reader]
+    # @raise [ArgumentError] If the given symbolic name is invalid.
+    def self.for(format, *args, &block)
+      ActsAsTable.for(format).reader(*args, &block)
+    end
+
+    attr_reader :row_model, :input, :options
+
+    # Returns a new ActsAsTable reader object using the given ActsAsTable row model, input stream and options.
+    #
+    # @param [ActsAsTable::RowModel] row_model
+    # @param [IO] input
+    # @param [Hash<Symbol, Object>] options
+    # @yieldparam [ActsAsTable::Reader] reader
+    # @yieldreturn [void]
+    # @return [ActsAsTable::Reader]
+    def initialize(row_model, input = $stdin, **options, &block)
+      @row_model, @input, @options = row_model, input, options.dup
+
+      if block_given?
+        case block.arity
+          when 1 then block.call(self)
+          else self.instance_eval(&block)
+        end
+      end
+    end
+
+    # Delegates to the input stream for this ActsAsTable reader object.
+    #
+    # @param [String] method_name
+    # @param [Array<Object>] args
+    # @yield [*args, &block]
+    # @yieldreturn [Object]
+    # @return [Object]
+    # @raise [NoMethodError]
+    def method_missing(method_name, *args, &block)
+      @input.respond_to?(method_name, false) ? @input.send(method_name, *args, &block) : super(method_name, *args, &block)
+    end
+
+    # Delegates to the input stream for this ActsAsTable reader object.
+    #
+    # @param [String] method_name
+    # @param [Boolean] include_all
+    # @return [Boolean]
+    def respond_to?(method_name, include_all = false)
+      @input.respond_to?(method_name, false) || super(method_name, include_all)
+    end
+
+    # Returns a pair, where the first element is the headers and the second element is a flag that indicates if input stream is at end of file.
+    #
+    # @return [Array<Object>]
+    # @raise [ArgumentError] If the headers do not match the ActsAsTable row model for this ActsAsTable reader object.
+    def read_headers
+      # @return [ActsAsTable::Headers::Array]
+      headers = @row_model.to_headers
+
+      # @return [Boolean]
+      eof = false
+
+      # @return [Array<Array<String>, nil>]
+      rows = ::Array.new(headers.size) { |index|
+        row, eof = *self.read_row
+
+        unless row.nil?
+          row += ::Array.new(headers[index].size - row.size) { nil }
+        end
+
+        row
+      }
+
+      if rows.any?(&:nil?)
+        raise ::ArgumentError.new("#{self.class}#read_headers - must exist")
+      end
+
+      unless [headers, rows].transpose.all? { |pair| pair[0] == pair[1] }
+        raise ::ArgumentError.new("#{self.class}#read_headers - invalid")
+      end
+
+      [rows, eof]
+    end
+
+    # Returns a pair, where the first element is the next row or +nil+ if input stream is at end of file and the second element indicates if input stream is at end of file.
+    #
+    # @return [Object]
+    def read_row
+      raise ::NotImplementedError.new("#{self.class}#read_row")
+    end
+
+    # Enumerates the rows in the input stream.
+    #
+    # @yieldparam [Array<String, nil>, nil] row
+    # @yieldreturn [void]
+    # @return [Enumerable<Array<String, nil>, nil>]
+    # @raise [ArgumentError] If the headers do not match the ActsAsTable row model for this ActsAsTable reader object.
+    def each_row(&block)
+      ::Enumerator.new { |enumerator|
+        headers, eof = *self.read_headers
+
+        until eof
+          row, eof = *self.read_row
+
+          unless eof
+            enumerator << row
+          end
+        end
+      }.each(&block)
+    end
+
+    # Returns a new ActsAsTable table object by reading all rows in the input stream.
+    #
+    # @return [ActsAsTable::Table]
+    # @raise [ArgumentError] If the name of a class for a given record does not match the class name for the corresponding ActsAsTable record model.
+    def read_table
+      ActsAsTable::Table.new do |table|
+        table.row_model = @row_model
+
+        self.each_row do |row|
+          records = table.from_row(row)
+
+          records.each do |record|
+            record.position = self.lineno
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_table/version.rb

@@ -0,0 +1,4 @@
+module ActsAsTable
+  # @return [String]
+  VERSION = '0.0.1'
+end

data/lib/acts_as_table/writer.rb

@@ -0,0 +1,116 @@
+module ActsAsTable
+  # ActsAsTable writer object.
+  #
+  # @!attribute [r] row_model
+  #   Returns the ActsAsTable row model for this ActsAsTable reader object.
+  #
+  #   @return [ActsAsTable::RowModel]
+  # @!attribute [r] output
+  #   Returns the output stream for this ActsAsTable reader object.
+  #
+  #   @return [IO]
+  # @!attribute [r] options
+  #   Returns the options for this ActsAsTable reader object.
+  #
+  #   @return [Hash<Symbol, Object>]
+  class Writer
+    # Returns a new ActsAsTable writer object based on a symbolic name using the given arguments.
+    #
+    # @param [Symbol] format
+    # @param [Array<Object>] args
+    # @yieldparam [ActsAsTable::Writer] writer
+    # @yieldreturn [void]
+    # @return [ActsAsTable::Writer]
+    # @raise [ArgumentError] If the given symbolic name is invalid.
+    def self.for(format, *args, &block)
+      ActsAsTable.for(format).writer(*args, &block)
+    end
+
+    attr_reader :row_model, :output, :options
+
+    # Returns a new ActsAsTable writer object using the given ActsAsTable row model, output stream and options.
+    #
+    # @param [ActsAsTable::RowModel] row_model
+    # @param [IO] output
+    # @param [Hash<Symbol, Object>] options
+    # @yieldparam [ActsAsTable::Writer] writer
+    # @yieldreturn [void]
+    # @return [ActsAsTable::Writer]
+    def initialize(row_model, output = $stdout, **options, &block)
+      @row_model, @output, @options = row_model, output, options.dup
+
+      if block_given?
+        self.write_prologue
+
+        case block.arity
+          when 1 then block.call(self)
+          else self.instance_eval(&block)
+        end
+
+        self.write_epilogue
+      end
+    end
+
+    # Delegates to the output stream for this ActsAsTable writer object.
+    #
+    # @param [String] method_name
+    # @param [Array<Object>] args
+    # @yield [*args, &block]
+    # @yieldreturn [Object]
+    # @return [Object]
+    # @raise [NoMethodError]
+    def method_missing(method_name, *args, &block)
+      @output.respond_to?(method_name, false) ? @output.send(method_name, *args, &block) : super(method_name, *args, &block)
+    end
+
+    # Delegates to the output stream for this ActsAsTable writer object.
+    #
+    # @param [String] method_name
+    # @param [Boolean] include_all
+    # @return [Boolean]
+    def respond_to?(method_name, include_all = false)
+      @output.respond_to?(method_name, false) || super(method_name, include_all)
+    end
+
+    # Writes the epilogue to the output stream.
+    #
+    # @return [ActsAsTable::Writer]
+    def write_epilogue
+      self
+    end
+
+    # Writes the prologue to the output stream.
+    #
+    # @return [ActsAsTable::Writer]
+    def write_prologue
+      # @return [ActsAsTable::Headers::Array]
+      headers = @row_model.to_headers
+
+      headers.each do |header|
+        self.write_row(header)
+      end
+
+      self
+    end
+
+    # Writes a record to the output stream.
+    #
+    # @param [ActiveRecord::Base] base
+    # @return [ActsAsTable::Writer]
+    # @raise [ArgumentError] If the name of a class for a given record does not match the class name for the corresponding ActsAsTable record model.
+    def write_base(base)
+      row = @row_model.to_row(base)
+
+      self.write_row(row)
+    end
+    alias_method :<<, :write_base
+
+    # Writes a row to the output stream.
+    #
+    # @param [Array<String, nil>, nil] row
+    # @return [ActsAsTable::Writer]
+    def write_row(row)
+      raise ::NotImplementedError.new("#{self.class}#write_row")
+    end
+  end
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_table
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mark Borkum
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard-activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard-activesupport-concern
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ActsAsTable is a Ruby on Rails plugin for working with tabular data.
+email:
+- mark.borkum@pnnl.gov
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- Rakefile
+- app/models/acts_as_table/belongs_to.rb
+- app/models/acts_as_table/column_model.rb
+- app/models/acts_as_table/foreign_key.rb
+- app/models/acts_as_table/foreign_key_map.rb
+- app/models/acts_as_table/has_many.rb
+- app/models/acts_as_table/has_many_target.rb
+- app/models/acts_as_table/lense.rb
+- app/models/acts_as_table/primary_key.rb
+- app/models/acts_as_table/record.rb
+- app/models/acts_as_table/record_error.rb
+- app/models/acts_as_table/record_model.rb
+- app/models/acts_as_table/row_model.rb
+- app/models/acts_as_table/table.rb
+- app/models/acts_as_table/value.rb
+- app/models/concerns/acts_as_table/record_model_class_methods.rb
+- app/models/concerns/acts_as_table/value_provider.rb
+- app/models/concerns/acts_as_table/value_provider_association_methods.rb
+- config/locales/en.yml
+- db/migrate/1_acts_as_table_migration.rb
+- lib/acts_as_table.rb
+- lib/acts_as_table/adapter.rb
+- lib/acts_as_table/engine.rb
+- lib/acts_as_table/headers.rb
+- lib/acts_as_table/mapper.rb
+- lib/acts_as_table/path.rb
+- lib/acts_as_table/reader.rb
+- lib/acts_as_table/version.rb
+- lib/acts_as_table/writer.rb
+homepage: https://github.com/pnnl/acts_as_table
+licenses:
+- BSD-3-Clause
+metadata:
+  bug_tracker_uri: https://github.com/pnnl/acts_as_table/issues
+  source_code_uri: https://github.com/pnnl/acts_as_table
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: A Ruby on Rails plugin for working with tabular data.
+test_files: []