acts_as_table 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e5e35bba33b684f86efbc6e25359aa1905e746349f8d620e5469979ff7b4ef73
+  data.tar.gz: c147a7b87ef0e222e755c0e91b3ea8c1c4f705ae67bc16c811c8069d09688acd
+SHA512:
+  metadata.gz: fd95f8e6caafb2fde253ce90a398fe7be97e42a5ab62f1c56b4fba341795f2f1d50b5c3f8dc1bb4747f2605d42a6123f4c3ccf103a2c9b66b3c6a7bd993fa22a
+  data.tar.gz: a5d3220b70279035c422e4e586f73c0f0579be8207a05b58c39c21dac8243a9a7eef7e0d657cce6fd5ed8c7e9b8b60d12d2b5f70319451f402596cf60c87edf5

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --markup-provider redcarpet --plugin activerecord --plugin activesupport-concern --plugin rails

data/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2020, Battelle Memorial Institute
+All rights reserved.
+
+1. Battelle Memorial Institute (hereinafter Battelle) hereby grants permission
+   to any person or entity lawfully obtaining a copy of this software and
+   associated documentation files (hereinafter "the Software") to redistribute
+   and use the Software in source and binary forms, with or without
+   modification.  Such person or entity may use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and may permit
+   others to do so, subject to the following conditions:
+
+   * Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimers.
+   * Redistributions in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+   * Other than as used herein, neither the name Battelle Memorial Institute or
+     Battelle may be used in any form whatsoever without the express written
+     consent of Battelle.
+
+2. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL BATTELLE OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,256 @@
+# ActsAsTable
+
+This is a Ruby on Rails plugin for working with tabular data.
+
+* https://github.com/pnnl/acts_as_table
+
+## Documentation
+
+### ActsAsTable Table Specification Models
+
+* {ActsAsTable::ColumnModel}
+* {ActsAsTable::RowModel}
+
+### ActsAsTable Record Specification Models
+
+* {ActsAsTable::BelongsTo}
+* {ActsAsTable::ForeignKey}
+* {ActsAsTable::ForeignKeyMap}
+* {ActsAsTable::HasMany}
+* {ActsAsTable::HasManyTarget}
+* {ActsAsTable::Lense}
+* {ActsAsTable::PrimaryKey}
+* {ActsAsTable::RecordModel}
+* {ActsAsTable::RecordModelClassMethods} (concern)
+* {ActsAsTable::ValueProvider} (concern)
+* {ActsAsTable::ValueProviderAssociationMethods} (concern)
+
+### ActsAsTable Table/Record Storage Models
+
+* {ActsAsTable::Record}
+* {ActsAsTable::RecordError}
+* {ActsAsTable::Table}
+* {ActsAsTable::Value}
+
+### ActsAsTable Serialization
+
+* {ActsAsTable::Headers}
+  * {ActsAsTable::Headers::Array}
+  * {ActsAsTable::Headers::Hash}
+* {ActsAsTable::Reader}
+* {ActsAsTable::Writer}
+
+### ActsAsTable Serialization Formats
+
+* [ActsAsTable::CSV](https://github.com/pnnl/acts_as_table_csv) (extension)
+
+### ActsAsTable Utilities
+
+* {ActsAsTable::Adapter}
+* {ActsAsTable::Configuration}
+* {ActsAsTable::Mapper}
+  * {ActsAsTable::Mapper::Base}
+  * {ActsAsTable::Mapper::BelongsTo}
+  * {ActsAsTable::Mapper::ForeignKey}
+  * {ActsAsTable::Mapper::HasAndBelongsToMany}
+  * {ActsAsTable::Mapper::HasMany}
+  * {ActsAsTable::Mapper::HasOne}
+  * {ActsAsTable::Mapper::Lense}
+  * {ActsAsTable::Mapper::PrimaryKey}
+  * {ActsAsTable::Mapper::RecordModel}
+  * {ActsAsTable::Mapper::RowModel}
+* {ActsAsTable::Path}
+
+## Dependencies
+
+* [ActiveRecord](https://github.com/rails/rails/tree/master/activerecord) (>= 4.2, < 6.1)
+
+## Installation
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest, official release of the ActsAsTable gem, do:
+```bash
+% [sudo] gem install acts_as_table
+```
+
+### Install ActsAsTable Migrations
+
+If the ActsAsTable gem is being used as part of a Ruby on Rails application, do:
+
+```bash
+% rake acts_as_table:install:migrations
+```
+
+See documentation for {ActsAsTable.configure} for example of modifying the table names for the ActsAsTable model classes.
+
+```bash
+% rake db:migrate
+```
+
+## Examples
+
+```ruby
+require 'acts_as_table'
+```
+
+### Table/Record Specification for Preexisting Ruby on Rails Application
+
+The preexisting Ruby on Rails application has the following model classes:
+
+* `app/models/blog.rb`
+
+```ruby
+class Blog < ActiveRecord::Base
+  validates_presence_of :title
+
+  belongs_to :user, required: true
+
+  has_many :posts
+end
+```
+
+* `app/models/post.rb`
+
+```ruby
+class Post < ActiveRecord::Base
+  validates_presence_of :title, :abstract
+
+  belongs_to :blog, required: true
+end
+```
+
+* `app/models/user.rb`
+
+```ruby
+class User < ActiveRecord::Base
+  validates_presence_of :login, :email
+
+  has_many :blogs
+end
+```
+
+The goal is to specify a table of instances of the `Post` class with the following structure:
+
+| Protected | Protected | Public | Public | Public | Public | Public |
+| :---: | :---: | :---: | :---: | :---: | :---: | :---: |
+| User | User | Blog | Post | Post | Post | Post |
+| Login Screen Name | Email Address | Title | Title | Abstract | Date Created | Date Modified |
+| `post.blog.user.login` | `post.blog.user.email` | `post.blog.title` | `post.title` | `post.abstract` | `post.created_at` | `post.updated_at` |
+
+The table has 3 header rows (viz., the metadata).
+
+The non-header rows (viz., the data) correspond to arrays of Ruby objects (viz., the values), where the elements of the array are obtained by traversing paths of ActiveRecord associations that terminate with ActiveRecord columns or Ruby attribute accessors.
+
+For example, the value of the "Protected,User,Login Screen Name" column is obtained by traversing the following path: `Post#blog` &rarr; `Blog#user` &rarr; `User#login`.
+
+Multi-level headers (of arbitrary depth) and corresponding paths are specified using the {ActsAsTable::Path} class.
+
+For example, the "Protected,User,Login Screen Name" is specified as follows:
+```ruby
+{
+  'Protected' => {
+    'User' => {
+      'Login Screen Name' => ActsAsTable::Path.new(Post).belongs_to(:blog).belongs_to(:user).attribute(:login),
+    },
+  },
+}
+```
+
+To achieve the goal, first, seed the database with a new ActsAsTable row model.
+
+* `db/seeds.rb`
+
+```ruby
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the rake db:seed (or created alongside the db with db:setup).
+#
+# Examples:
+#
+#   cities = City.create([{ name: 'Chicago' }, { name: 'Copenhagen' }], without_protection: true)
+#   Mayor.create(name: 'Emanuel', city: cities.first)
+
+ActsAsTable::RowModel.create(name: 'ActsAsTable row model for post->blog->user') do |row_model|
+  row_model.draw do
+    # @return [ActsAsTable::Path<Post>]
+    post_path = ActsAsTable::Path.new(Post)
+
+    # @return [ActsAsTable::Path<Blog>]
+    post_blog_path = post_path.belongs_to(:blog)
+
+    # @return [ActsAsTable::Path<User>]
+    post_blog_user_path = post_blog_path.belongs_to(:user)
+
+    self.columns = {
+      'Protected' => {
+        'User' => {
+          'Login Screen Name' => post_blog_user_path.attribute(:login),
+          'Email Address' => post_blog_user_path.attribute(:email),
+        },
+      },
+      'Public' => {
+        'Blog' => {
+          'Title' => post_blog_path.attribute(:title),
+        },
+        'Post' => {
+          'Title' => post_path.attribute(:title),
+          'Abstract' => post_path.attribute(:abstract),
+          'Date Created' => post_path.attribute(:created_at),
+          'Date Modified' => post_path.attribute(:updated_at),
+        },
+      },
+    }
+
+    # @return [ActsAsTable::Mapper::RecordModel<User>]
+    post_blog_user_model = model 'User' do
+      attribute :login, post_blog_user_path.attribute(:login)
+      attribute :email, post_blog_user_path.attribute(:email)
+    end
+
+    # @return [ActsAsTable::Mapper::RecordModel<Blog>]
+    post_blog_model = model 'Blog' do
+      attribute :title, post_blog_path.attribute(:title)
+
+      belongs_to :user, post_blog_user_model
+    end
+
+    # @return [ActsAsTable::Mapper::RecordModel<Post>]
+    post_model = model 'Post' do
+      attribute :title, post_path.attribute(:title)
+      attribute :abstract, post_path.attribute(:abstract)
+      attribute :created_at, post_path.attribute(:created_at)
+      attribute :updated_at, post_path.attribute(:updated_at)
+
+      belongs_to :blog, post_blog_model
+    end    
+
+    self.root_model = post_model
+  end
+end
+```
+
+Finally, serialize the data using the [ActsAsTable::CSV](https://github.com/pnnl/acts_as_table_csv) extension:
+```ruby
+# @return [ActsAsTable::RowModel]
+row_model = ActsAsTable::RowModel.find(1)
+
+# @return [ActiveRecord::Relation<Post>]
+posts = Post.all
+
+ActsAsTable.for(:csv).writer(row_model, $stdout) do |writer|
+  posts.each do |post|
+    writer << post
+  end
+end
+```
+
+See documentation for [ActsAsTable::CSV](https://github.com/pnnl/acts_as_table_csv) extension for more parsing/serializing examples.
+
+## Author
+
+* [Mark Borkum](https://github.com/markborkum)
+
+## License
+
+This software is licensed under a 3-clause BSD license.
+
+For more information, see the accompanying {file:LICENSE} file.

data/Rakefile

@@ -0,0 +1,13 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'yard'
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['{app,lib}/**/*.rb']
+end

data/app/models/acts_as_table/belongs_to.rb

@@ -0,0 +1,81 @@
+module ActsAsTable
+  # ActsAsTable singular macro association.
+  #
+  # @!attribute [rw] macro
+  #   Returns the symbolic name for the macro for this ActsAsTable singular macro association.
+  #
+  #   @note The macro must be either `:belongs_to` or `:has_one`.
+  #
+  #   @return [String]
+  # @!attribute [rw] method_name
+  #   Returns the method name for this ActsAsTable singular macro association.
+  #
+  #   @return [String]
+  class BelongsTo < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.belongs_tos_table
+
+    # Returns the ActsAsTable row model for this ActsAsTable singular macro association.
+    belongs_to :row_model, **{
+      class_name: 'ActsAsTable::RowModel',
+      inverse_of: :belongs_tos,
+      required: true,
+    }
+
+    # Returns the source ActsAsTable record model for this ActsAsTable singular macro association.
+    belongs_to :source_record_model, **{
+      class_name: 'ActsAsTable::RecordModel',
+      inverse_of: :belongs_tos_as_source,
+      required: true,
+    }
+
+    # Returns the target ActsAsTable record model for this ActsAsTable singular macro association.
+    belongs_to :target_record_model, **{
+      class_name: 'ActsAsTable::RecordModel',
+      inverse_of: :belongs_tos_as_target,
+      required: true,
+    }
+
+    validates :macro, **{
+      inclusion: {
+        in: ['belongs_to', 'has_one'],
+      },
+      presence: true,
+    }
+
+    validates :method_name, **{
+      presence: true,
+    }
+
+    validate :macro_and_method_name_must_be_valid_association, **{
+      if: ::Proc.new { |belongs_to| belongs_to.macro.present? && belongs_to.method_name.present? },
+    }
+
+    private
+
+    # @return [void]
+    def macro_and_method_name_must_be_valid_association
+      self.source_record_model.try { |record_model| record_model.class_name.constantize rescue nil }.try { |source_klass|
+        # @return [ActiveRecord::Reflection::MacroReflection]
+        reflection = source_klass.reflect_on_association(self.method_name)
+
+        if reflection.nil?
+          self.errors.add('method_name', :required)
+        elsif self.macro.eql?(reflection.macro.to_s)
+          self.target_record_model.try { |record_model| record_model.class_name.constantize rescue nil }.try { |target_klass|
+            unless reflection.klass == target_klass
+              self.errors.add('target_record_model_id', :invalid)
+            end
+          }
+        else
+          self.errors.add('method_name', :invalid)
+        end
+      }
+
+      return
+    end
+  end
+end

data/app/models/acts_as_table/column_model.rb

@@ -0,0 +1,89 @@
+module ActsAsTable
+  # ActsAsTable column model.
+  #
+  # @!attribute [rw] name
+  #   Returns the name for this ActsAsTable column model.
+  #
+  #   @return [String]
+  # @!attribute [rw] position
+  #   Returns the position of this ActsAsTable column model.
+  #
+  #   @return [Integer]
+  # @!attribute [rw] separator
+  #   Returns the separator for the name of this ActsAsTable column model. By default, this is `,`.
+  #
+  #   @return [String]
+  class ColumnModel < ::ActiveRecord::Base
+    # @!parse
+    #   include ActsAsTable::ValueProvider
+    #   include ActsAsTable::ValueProviderAssociationMethods
+
+    self.table_name = ActsAsTable.column_models_table
+
+    # Returns the ActsAsTable row model for this ActsAsTable column model.
+    belongs_to :row_model, **{
+      class_name: 'ActsAsTable::RowModel',
+      inverse_of: :column_models,
+      required: true,
+    }
+
+    # Returns the ActsAsTable foreign keys for this ActsAsTable column model.
+    has_many :foreign_keys, **{
+      autosave: true,
+      class_name: 'ActsAsTable::ForeignKey',
+      dependent: :nullify,
+      foreign_key: 'column_model_id',
+      inverse_of: :column_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable attribute accessors for this ActsAsTable column model.
+    has_many :lenses, **{
+      autosave: true,
+      class_name: 'ActsAsTable::Lense',
+      dependent: :nullify,
+      foreign_key: 'column_model_id',
+      inverse_of: :column_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable primary keys for this ActsAsTable column model.
+    has_many :primary_keys, **{
+      autosave: true,
+      class_name: 'ActsAsTable::PrimaryKey',
+      dependent: :nullify,
+      foreign_key: 'column_model_id',
+      inverse_of: :column_model,
+      validate: true,
+    }
+
+    # Returns the ActsAsTable values that have been provided by this ActsAsTable column model.
+    has_many :values, **{
+      class_name: 'ActsAsTable::Value',
+      dependent: :restrict_with_exception,
+      foreign_key: 'column_model_id',
+      inverse_of: :column_model,
+    }
+
+    validates :name, **{
+      presence: true,
+    }
+
+    validates :position, **{
+      numericality: {
+        greater_than_or_equal_to: 1,
+        only_integer: true,
+      },
+      presence: true,
+      uniqueness: {
+        scope: ['row_model_id'],
+      },
+    }
+
+    validates :separator, **{
+      length: {
+        minimum: 1,
+      },
+    }
+  end
+end