proforma 1.0.0.pre.alpha

data/lib/proforma/modeling/collection.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Proforma
+  module Modeling
+    # A general purpose grouping of modeling objects.  When compiled, they will each be
+    # compiled once then their output(s) are combined and flattened.
+    class Collection
+      acts_as_hashable
+
+      attr_writer :children
+
+      def initialize(children: [])
+        @children = ModelFactory.array(children)
+      end
+
+      def children
+        Array(@children)
+      end
+
+      def compile(data, evaluator)
+        children.map do |section|
+          section.respond_to?(:compile) ? section.compile(data, evaluator) : section
+        end.flatten
+      end
+    end
+  end
+end

data/lib/proforma/modeling/data_table.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'data_table/aggregator'
+require_relative 'data_table/column'
+
+module Proforma
+  module Modeling
+    # A table that understands how to be compiled against a data source.
+    class DataTable
+      include Compiling::Compilable
+      acts_as_hashable
+
+      attr_accessor :property
+
+      attr_writer :aggregators,
+                  :columns,
+                  :empty_message
+
+      def initialize(
+        aggregators: [],
+        columns: [],
+        empty_message: '',
+        property: nil
+      )
+        @aggregators    = Aggregator.array(aggregators)
+        @columns        = Column.array(columns)
+        @empty_message  = empty_message
+        @property       = property
+      end
+
+      def empty_message
+        @empty_message.to_s
+      end
+
+      def aggregators
+        Array(@aggregators)
+      end
+
+      def columns
+        Array(@columns)
+      end
+
+      def compile(data, evaluator)
+        records = array(evaluator.value(data, property))
+
+        return Text.new(value: empty_message) if show_empty_message?(records)
+
+        meta_data = make_aggregator_meta_data(records, evaluator)
+
+        Table.new(
+          body: make_body(records, evaluator),
+          footer: make_footer(meta_data, evaluator),
+          header: make_header({}, evaluator)
+        )
+      end
+
+      private
+
+      def make_aggregator_meta_data(records, evaluator)
+        Compiling::Aggregation.new(aggregators, evaluator).add(records).to_hash
+      end
+
+      def footer?
+        columns.select(&:footer?).any?
+      end
+
+      def header?
+        columns.select(&:header?).any?
+      end
+
+      def show_empty_message?(records)
+        records.empty? && !empty_message.empty?
+      end
+
+      def make_footer(data, evaluator)
+        make(footer?, :compile_footer_cell, data, evaluator)
+      end
+
+      def make_header(data, evaluator)
+        make(header?, :compile_header_cell, data, evaluator)
+      end
+
+      def make(visible, row_compile_method, data, evaluator)
+        return Table::Section.new unless visible
+
+        rows = [
+          make_row(row_compile_method, data, evaluator)
+        ]
+
+        Table::Section.new(rows: rows)
+      end
+
+      def make_body(records, evaluator)
+        rows = records.map do |record|
+          make_row(:compile_body_cell, record, evaluator)
+        end
+
+        Table::Section.new(rows: rows)
+      end
+
+      def make_row(method, record, evaluator)
+        cells = columns.map do |column|
+          column.send(method, record, evaluator)
+        end
+
+        Table::Row.new(cells: cells)
+      end
+    end
+  end
+end

data/lib/proforma/modeling/data_table/aggregator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Proforma
+  module Modeling
+    class DataTable
+      # An Aggregator is a table aggregator function configuration.
+      class Aggregator
+        acts_as_hashable
+
+        module Function
+          SUM = :sum
+          AVE = :ave
+        end
+        include Function
+
+        attr_accessor :property
+
+        attr_writer :function, :name
+
+        def initialize(function: SUM, name: '', property: nil)
+          @function = function
+          @name     = name
+          @property = property
+        end
+
+        def function
+          @function || SUM
+        end
+
+        def name
+          @name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/proforma/modeling/data_table/column.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Proforma
+  module Modeling
+    class DataTable
+      # An explicit table column that understands how to compile header, body, and footer cells
+      # from records.
+      class Column
+        include Modeling::Types::Align
+        include Compiling::Compilable
+        acts_as_hashable
+
+        attr_writer :align,
+                    :body,
+                    :footer,
+                    :header,
+                    :width
+
+        def initialize(
+          align: LEFT,
+          body: '',
+          footer: '',
+          header: '',
+          width: nil
+        )
+          @align  = align
+          @body   = body
+          @footer = footer
+          @header = header
+          @width  = width
+        end
+
+        def align
+          @align || LEFT
+        end
+
+        def body
+          @body.to_s
+        end
+
+        def footer
+          @footer.to_s
+        end
+
+        def header
+          @header.to_s
+        end
+
+        def width
+          @width ? @width.to_f : nil
+        end
+
+        def compile_header_cell(record, evaluator)
+          Modeling::Table::Cell.new(
+            align: align,
+            text: evaluator.text(record, header),
+            width: width
+          )
+        end
+
+        def compile_body_cell(record, evaluator)
+          Modeling::Table::Cell.new(
+            align: align,
+            text: evaluator.text(record, body),
+            width: width
+          )
+        end
+
+        def compile_footer_cell(record, evaluator)
+          Modeling::Table::Cell.new(
+            align: align,
+            text: evaluator.text(record, footer),
+            width: width
+          )
+        end
+
+        def footer?
+          !footer.to_s.empty?
+        end
+
+        def header?
+          !header.to_s.empty?
+        end
+      end
+    end
+  end
+end

data/lib/proforma/modeling/generic_container.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Proforma
+  module Modeling
+    # This can be used as a super-class for models which are basically containers for
+    # simple arrays of elements
+    class GenericContainer
+      def initialize(child_key, child_class, children = [])
+        raise ArgumentError, 'child_key is required'   unless child_key
+        raise ArgumentError, 'child_class is required' unless child_class
+
+        @child_class = child_class
+        @child_key   = child_key.to_s.to_sym
+        @children    = child_class.array(children)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name.to_s == child_key.to_s ||
+          method_name.to_s == child_setter_name ||
+          super
+      end
+
+      def method_missing(method_name, *args, &block)
+        if method_name.to_s == child_key.to_s
+          Array(children)
+        elsif method_name.to_s == child_setter_name
+          @children = args
+        else
+          super
+        end
+      end
+
+      def compile(data, evaluator)
+        compiled_children = children.map { |child| child.compile(data, evaluator) }
+
+        args = {}.tap { |hash| hash[child_key] = compiled_children }
+
+        self.class.new(args)
+      end
+
+      private
+
+      attr_reader :child_class, :child_key, :children
+
+      def child_setter_name
+        "#{child_key}="
+      end
+    end
+  end
+end

data/lib/proforma/modeling/grouping.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Proforma
+  module Modeling
+    # A grouping is an inverted collection, meaning, it iterates each child once per record
+    # instead of only one time.  It also provides a mechanic to traverse data to tap
+    # nested child data (through the property attribute.)
+    class Grouping
+      include Compiling::Compilable
+      acts_as_hashable
+
+      attr_accessor :property
+
+      attr_writer :children
+
+      def initialize(children: [], property: nil)
+        @children = ModelFactory.array(children)
+        @property = property
+      end
+
+      def children
+        Array(@children)
+      end
+
+      def compile(data, evaluator)
+        records = array(evaluator.value(data, property))
+
+        records.map { |record| Collection.new(children: children).compile(record, evaluator) }
+               .flatten
+      end
+    end
+  end
+end

data/lib/proforma/modeling/header.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'text'
+
+module Proforma
+  module Modeling
+    # A Header is an object representation of an important text-based title.
+    class Header < Text
+    end
+  end
+end

data/lib/proforma/modeling/pane.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'pane/column'
+require_relative 'pane/line'
+
+module Proforma
+  module Modeling
+    # Think of a pane like a pivoted table.  It has columns but not in the same respect as
+    # a table's columns.  For a pane, it makes up a vertical section.  Each column (section)
+    # then has a number of lines which holds the label:value pairs that facilitates data
+    # rendering.
+    class Pane
+      include Compiling::Compilable
+      acts_as_hashable
+
+      attr_writer :columns
+
+      def initialize(columns: [])
+        @columns = Column.array(columns)
+      end
+
+      def columns
+        Array(@columns)
+      end
+
+      def compile(data, evaluator)
+        compiled_columns = columns.map { |column| column.compile(data, evaluator) }
+
+        self.class.new(columns: compiled_columns)
+      end
+    end
+  end
+end