reportinator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb46422febcfaac711a20fbb21418ed224bc22e59468e9295dfccdd0c7ca309e
+  data.tar.gz: afba11ce1ecc80668797392b5c24eeffc715d349b78f93fa7d6e7ea8dfdc096a
+SHA512:
+  metadata.gz: 8c604e8d6b30dff8df130dd6af08fcbc7a6ee0a4bb4a9e3c39478e97f2d3a2bb073c4543dcd2f366c4a39b5b15c97925d64bcba4060ed344c4c95de616507d91
+  data.tar.gz: 678d1ed69042d72e8f0c146abcc0a55becb31a7961f034bb58d63a1f2999100443f13e91fd71129bcaab33616a1bc0361bbac7dd62ae5003c21159574c2c4ef0

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 2.6

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-10-04
+- Initial release
+
+### Added
+- Value parser
+- Method parser
+- Preset report type
+- Model report type
+- Readme with report tutorial

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at dev@moxvallix.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in reportinator.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "standard", "~> 1.3"

data/Gemfile.lock

@@ -0,0 +1,79 @@
+PATH
+  remote: .
+  specs:
+    reportinator (0.1.0)
+      activemodel (~> 7.0)
+      require_all (~> 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.0.4)
+      activesupport (= 7.0.4)
+    activesupport (7.0.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    concurrent-ruby (1.1.10)
+    diff-lcs (1.5.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.2)
+    minitest (5.16.3)
+    parallel (1.22.1)
+    parser (3.1.2.1)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.6.0)
+    require_all (3.0.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.1)
+    rubocop (1.35.1)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.20.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.21.0)
+      parser (>= 3.1.1.0)
+    rubocop-performance (1.14.3)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    standard (1.16.1)
+      rubocop (= 1.35.1)
+      rubocop-performance (= 1.14.3)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.3.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  rake (~> 13.0)
+  reportinator!
+  rspec (~> 3.0)
+  standard (~> 1.3)
+
+BUNDLED WITH
+   2.3.11

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Moxvallix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,397 @@
+# Reportinator
+## Behold! My Report-inator!
+
+**Warning: this gem can execute methods based on strings defined in a JSON file. Use at your own caution.**
+**This gem has not been security audited, and should not be used in a production environment!**
+
+Reportinator is a gem that allows you to easily define a report using a JSON file.
+Report templates can reference other report templates, allowing for report "partials" to easily be re-used.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add reportinator
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install reportinator
+
+## Usage
+### Creating my first Report
+Let's start by considering what we want our output to be.
+Say we want a multiplication table, like such:
+| nx1 | nx2 | nx3 | nx4 | nx5 |
+|-----|-----|-----|-----|-----|
+|   1 |   2 |   3 |   4 |   5 |
+|   2 |   4 |   6 |   8 |  10 |
+|   3 |   6 |   9 |  12 |  15 |
+|   4 |   8 |  12 |  16 |  20 |
+|   5 |  10 |  15 |  20 |  25 |
+
+Make a new file in your `app/reports` directory.
+Name it `multiplication.report.json`
+
+Set it's type to ":preset". The ":preset" type takes one parameter, "data",
+and returns any values passed inside it, but with their values parsed.
+We put a colon in front of the word "preset", such that the value parser
+knows to turn it into a symbol.
+
+```
+{
+  "type": ":preset"
+}
+```
+
+Next we need to give it parameters to be passed into the report.
+":preset" only accepts the "data" parameter.
+Add "data" to a "params" object, and set it to be an empty array.
+
+```
+{
+  "type": ":preset",
+  "params": {
+    "data": []   
+  }
+}
+```
+
+You can now try running this report:
+
+```
+> Reportinator.report("multiplication")
+=> []
+```
+
+If all went to plan, you should have gotten an empty array.
+Let's now add some data to this bad boy.
+
+```
+{
+  "type": ":preset",
+  "params": {
+    "data": ["nx1","nx2","nx3","nx4","nx5"]   
+  }
+}
+```
+```
+> Reportinator.report("multiplication")
+=> [["nx1", "nx2", "nx3", "nx4", "nx5"]]
+```
+
+Now we could add the other rows ourselves, by adding more rows to "data":
+
+```
+{
+  "type": ":preset",
+  "params": {
+    "data": [
+      ["nx1","nx2","nx3","nx4","nx5"],
+      [1, 2, 3, 4, 5],
+      [2, 4, 6, 8, 10],
+      [3, 6, 9, 12, 15],
+      [4, 8, 12, 16, 20],
+      [5, 10, 15, 20, 25]
+    ]   
+  }
+}
+```
+```
+> Reportinator.report("multiplication")
+=> 
+[
+  ["nx1", "nx2", "nx3", "nx4", "nx5"],
+  [1, 2, 3, 4, 5],
+  [2, 4, 6, 8, 10],
+  [3, 6, 9, 12, 15],
+  [4, 8, 12, 16, 20],
+  [5, 10, 15, 20, 25]
+]
+```
+
+However, there is a cleaner way of doing this.
+Move your entire report object inside of an array.
+This allows us to string reports together in the same template.
+
+```
+[
+  {
+    "type": ":preset",
+    "params": {
+      "data": ["nx1","nx2","nx3","nx4","nx5"]   
+    }
+  }
+]
+```
+
+Add a new report object underneath the first.
+This time, the type will be ":model".
+
+":model" reports take two parameters:
+  1. "target"
+  2. "method_list"
+
+Add both these keys to the "params" of the second report object.
+Set both to be an empty array.
+
+```
+[
+  {
+    "type": ":preset",
+    "params": {
+      "data": ["nx1","nx2","nx3","nx4","nx5"]   
+    }
+  },
+  {
+    "type": ":model",
+    "params": {
+      "target": [],
+      "method_list": []
+    }
+  }
+]
+```
+
+Model reports take a target, as specified in "target", and run methods against it,
+specified in "method_list", saving the outputs of each to the row.
+
+If the target is enumerable, said methods will run on each enumeration of the target,
+each enumeration adding a new row to the report.
+
+A method is specified by either a symbol, array or hash.
+Lets take the string "100" as our target.
+
+If our method was to be `":reverse"`, it would be the same as running"
+
+```
+> "100".reverse
+=> "001"
+```
+
+We can chain methods using an array. For example: `[":reverse", ":to_i"]`
+
+```
+> "100".reverse.to_i
+=> 1
+```
+
+Methods inside a hash allow for parameters to be passed to the method.
+The value of the hash are passed as the parameters, and an array is passed
+as multiple parameters.
+
+Eg. `{"gsub": ["0", "1"]}`
+
+```
+> "100".gsub("0", "1")
+=> "111"
+```
+
+In Ruby, it turns out the multiplication "*" sign is a method.
+Using this, we can write a much smarter report.
+
+```
+[
+  {
+    "type": ":preset",
+    "params": {
+      "data": ["nx1","nx2","nx3","nx4","nx5"]   
+    }
+  },
+  {
+    "type": ":model",
+    "params": {
+      "target": [1, 2, 3, 4, 5],
+      "method_list": [{"*": 1},{"*": 2},{"*": 3},{"*": 4},{"*": 5}]
+    }
+  }
+]
+```
+
+The "*" is behaving exactly the same way as our "gsub" example earlier.
+
+If we run our report again:
+
+```
+> Reportinator.report("multiplication")
+=> 
+[
+  ["nx1", "nx2", "nx3", "nx4", "nx5"],
+  [1, 2, 3, 4, 5],
+  [2, 4, 6, 8, 10],
+  [3, 6, 9, 12, 15],
+  [4, 8, 12, 16, 20],
+  [5, 10, 15, 20, 25]
+]
+```
+
+The result should be exactly the same.
+
+This is pretty good, but we can do better!
+Notice how the "target" was an array? As it is enumerable,
+we could run our methods against each element within it.
+
+But what if we wanted to have 10 rows? Or 50? Soon our array is going to get pretty long.
+
+This is where a range would be perfect. Set the start value to 1, the end to whatever number we need,
+and then we go from there.
+
+Unfortunately, we can't use a range in JSON.
+
+... or can we?
+
+Reportinator has a bunch of handy built in functions, for converting strings.
+We have already seen ":symbol" to make a string into a symbol.
+
+We won't explore all the functions now, but we will explore "!r".
+Or more specifically, "!rn", which auto converts strings into numbers as well.
+
+We can make a range simply by writing "!rn 1,5". It takes the number before the comma,
+as the start of the range, and the one after as the end.
+
+We can test this with the actual parse method:
+
+```
+> Reportinator::ValueParser.parse("!rn 1, 5")
+=> (1..5)
+```
+
+Let's add this now as the target of our report:
+
+```
+[
+  {
+    "type": ":preset",
+    "params": {
+      "data": ["nx1","nx2","nx3","nx4","nx5"]   
+    }
+  },
+  {
+    "type": ":model",
+    "params": {
+      "target": "!rn 1,5",
+      "method_list": [{"*": 1},{"*": 2},{"*": 3},{"*": 4},{"*": 5}]
+    }
+  }
+]
+```
+
+Finally, rather than peering at the console to see if it worked,
+lets put it into a csv.
+
+```
+> Reportinator.output("multiplication.csv","multiplication")
+=> "multiplication.csv"
+```
+
+Open the csv up in your spreadsheet viewer of choice, and revel
+in your brand new report!
+### Reports in more detail
+#### The Report Template Object
+A Report template has four attributes:
+
+| key       | type   | description                                        |
+|-----------|--------|----------------------------------------------------|
+| type      | symbol | specifies the report type to use                   |
+| variables | hash   | defines variables to be used with the `$` function |
+| template  | string | references another template to load and merge with |
+| params    | hash   | report specific parameters                         |
+
+#### Reportinator String Parse Cheatsheet
+| prefix | example                     | output                                     |
+|--------|-----------------------------|--------------------------------------------|
+| `:`    | ":symbol"                   | :symbol                                    |
+| `&`    | "&Constant"                 | Constant                                   |
+| `$`    | "$variable"                 | Value of key `variable` in variables hash. |
+| `!a`   | "!a 1,2,3"                  | 6                                          |
+| `!d`   | "!d 1970-01-01"             | 1970-01-01 00:00:00                        |
+| `!n`   | "!n 100"                    | 100                                        |
+| `!r`   | "!r a,z"                    | ("a".."z")                                 |
+| `!rd`  | "!rd 1970-01-01,1979-01-01" | (1970-01-01 00:00:00..1979-01-01 00:00:00) |
+| `!rn`  | "!rn 1,100"                 | (1..100)                                   |
+
+#### Reportinator Method Parse Cheatsheet
+When an array has a string as it's first value, and that string has the `#` prefix,
+that string is parsed, and the result becomes the target of the following methods.
+
+Hashes within the array take the first key in the hash as the method,
+and the first value as parameters for that method. If the first value
+is an array, each item in the array is sent as a seperate parameter.
+
+Subsequent symbols in the array are sent as methods to the target.
+| method array                                   | ruby equivalent               |
+|------------------------------------------------|-------------------------------|
+| `["#&Date", ":today"]`                         | Date.today                    |
+| `["#&Date", ":today", ":to_s"]`                | Date.today.to_s               |
+| `["#&Date", ":today", {"strftime": "%b, %Y"}]` | Date.today.strftime("%b, %Y") |
+| `["#&Range", {"new": [1,100]}]`                | Range.new(1, 100)             |
+
+### Where to put my Reports?
+By default, Reportinator checks `app/reports` for reports.
+It checks for files named `*.json` and `*.report.json`
+More locations and suffixes can be added in the config.
+
+### Getting your Report's Output
+`Reportinator.report(template, params)` will output a two dimensional array.
+If you picture this as a table, each sub array is a row.
+`params` is optional.
+
+`Reportinator.output(template, params, filename)` will output the report to a csv,
+in the configured output directory.
+`params` and `filename` are optional.
+
+Template is the name of the template file, minus the ".json" suffix.
+Here is how templates are resolved:
+- "profit" => "app/reports/profit.json"
+- "users/joined" => "app/reports/users/joined.json"
+
+Params is a hash, accepting the same keys as a template would.
+Params are merged with those provided by the template, overriding any conflicts.
+
+### Configuring Reportinator
+```
+Reportinator.configuration do |config|
+    config.output_directory = "my/report/dir"
+    config.report_directories = ["first/directory","other/directory"]
+    config.report_suffixes = ["custom.json", "txt"]
+    config.report_types = {
+        my_type: "MyModule::MyReportType"
+    }
+end
+```
+Configuration set will not override the default configuration.
+The keys used in report types, eg. `my_type`, will be the same used in the "type" field
+of the reports.
+
+### Making a Custom Report Type
+The requirements to make a Report are very simple.
+1. The report must inherit from `Reportinator::Report`
+2. The report must provide a `data` method, which returns a one or two dimensional array.
+
+For example, this is the entire code for the Preset Report:
+```
+module Reportinator
+    class PresetReport < Report
+        attribute :data, default: []
+    end
+end
+```
+Once a report has been written, it must be registed as a report type.
+See the configuration section for more details.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/reportinator. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/reportinator/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Reportinator project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/reportinator/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/app/reports/example.report.json

@@ -0,0 +1,20 @@
+[
+  {
+    "type": ":preset",
+    "variables": {"variable": "i am a variable"},
+    "params": {
+      "data": [
+        "string", ":symbol", "&Reportinator",
+        "$variable", "!i 1234", "!a !i 2, 2",
+        ["#!d 1970-01-01", {"strftime": "%b, %Y"}], "!r !i 1, !i 5"
+      ]
+    }
+  },
+  {
+    "type": ":model",
+    "params": {
+      "target": ["#&Reportinator", ":config"],
+      "method_list": [":configured_directories", ":configured_suffixes", ":configured_types"]
+    }
+  }
+]

data/app/reports/multiplication.report.json

@@ -0,0 +1,15 @@
+[
+  {
+    "type": ":preset",
+    "params": {
+      "data": ["nx1","nx2","nx3","nx4","nx5"]   
+    }
+  },
+  {
+    "type": ":model",
+    "params": {
+      "target": "!rn 1,5",
+      "method_list": [{"*": 1},{"*": 2},{"*": 3},{"*": 4},{"*": 5}]
+    }
+  }
+]

data/lib/reportinator/config.rb

@@ -0,0 +1,28 @@
+module Reportinator
+  class Config < Base
+    DEFAULT_TYPES = {
+      model: "Reportinator::ModelReport",
+      preset: "Reportinator::PresetReport"
+    }
+    DEFAULT_REPORT_DIRS = ["reports", "app/reports"]
+    DEFAULT_REPORT_SUFFIXES = ["report.json", "json"]
+
+    attribute :report_directories, default: []
+    attribute :report_suffixes, default: []
+    attribute :report_types, default: {}
+    attribute :output_directory, default: "reports"
+
+    def configured_directories
+      DEFAULT_REPORT_DIRS + report_directories
+    end
+
+    def configured_suffixes
+      DEFAULT_REPORT_SUFFIXES + report_suffixes
+    end
+
+    def configured_types
+      types = DEFAULT_TYPES
+      types.merge(report_types)
+    end
+  end
+end

data/lib/reportinator/loader.rb

@@ -0,0 +1,112 @@
+module Reportinator
+  class Loader < Base
+    attribute :type
+    attribute :template
+    attribute :variables
+    attribute :params
+
+    def self.data_from_template(template, additional_params = {})
+      template_data = load_template(template, additional_params)
+      return split_rows(template_data.data) unless template_data.instance_of?(Array)
+      output = []
+      template_data.each { |report| output += report.data }
+      split_rows(output)
+    end
+
+    def self.load_template(template, additional_params = {})
+      data = parse_template(template)
+      return load_multiple(data, additional_params) if data.instance_of?(Array)
+      load_singular(data, additional_params)
+    end
+
+    def self.load_multiple(data, additional_params)
+      data.map { |report| load_singular(report, additional_params) }
+    end
+
+    def self.load_singular(data, additional_params)
+      data.merge!(additional_params) { |key, old_value, new_value| merge_values(new_value, old_value) }
+      filtered_data = filter_params(data, attribute_names)
+      variables = filtered_data[:variables]
+      parsed_data = ValueParser.parse(filtered_data, variables)
+      new(parsed_data).report
+    end
+
+    def self.find_template(template)
+      suffixes = config.configured_suffixes
+      directories = config.configured_directories
+      template_files = suffixes.map { |suffix| (suffix.present? ? "#{template}.#{suffix}" : template) }
+      template_paths = directories.map { |dir| template_files.map { |file| "#{dir}/#{file}" } }
+      template_paths.flatten!
+      template_paths.each do |path|
+        return path if File.exist? path
+      end
+      raise "Missing template: #{template}. Searched: #{template_paths}"
+    end
+
+    def self.parse_template(template)
+      file = find_template(template)
+      begin
+        json = File.read(file)
+        JSON.parse(json, symbolize_names: true)
+      rescue
+        raise "Error parsing template file: #{file}"
+      end
+    end
+
+    def self.split_rows(data)
+      data = data.instance_of?(Array) ? data : [data]
+      rows = []
+      temp = []
+      data.each do |col|
+        if col.instance_of?(Array)
+          rows << temp unless temp.empty?
+          temp = []
+          rows << col
+        else
+          temp << col
+        end
+      end
+      rows << temp unless temp.empty?
+      rows
+    end
+
+    def self.filter_params(params, allowed_params)
+      filtered_params = params.select { |param| allowed_params.include? param.to_s }
+      if params.size > filtered_params.size
+        invalid_params = (params.keys - filtered_params.keys).map { |key| key.to_s }
+        logger.warn "Invalid attributes found: #{invalid_params} Valid attributes are: #{allowed_params}"
+      end
+      filtered_params
+    end
+
+    def self.merge_values(new_value, old_value)
+      return old_value.merge(new_value) if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+      new_value
+    end
+
+    def report
+      if template.present?
+        additional_params = {type: type, variables: variables, params: params}
+        self.class.load_template(template, additional_params.compact)
+      else
+        attribute_list = report_class.attribute_names
+        filtered_params = self.class.filter_params(params, attribute_list)
+        report_class.new(filtered_params)
+      end
+    end
+
+    def report_class
+      types = config.configured_types
+      raise "Invalid type: #{type}" unless types.include? type
+      types[type].constantize
+    end
+
+    def template_file
+      self.class.find_template(template)
+    end
+
+    def template_data
+      self.class.parse_template(template)
+    end
+  end
+end

data/lib/reportinator/parsers/method.rb

@@ -0,0 +1,61 @@
+module Reportinator
+  class MethodParser < Base
+    attribute :target
+    attribute :method
+
+    def self.parse(target, method)
+      new(target: target, method: method).output
+    end
+
+    def output
+      return send_value(target, method) if method_class == Symbol
+      return parse_array_method if method_class == Array
+      return parse_hash_method if method_class == Hash
+      nil
+    end
+
+    def method_class
+      method.class
+    end
+
+    def parse_array_method
+      raise "Not an array" unless method_class == Array
+      valid = false
+      output = target
+      method.each do |m|
+        value = parse_method(output, m)
+        next unless value.present?
+        valid = true
+        output = value
+      end
+      return output if valid
+      nil
+    end
+
+    def parse_hash_method
+      raise "Not a hash" unless method_class == Hash
+      data = method.first
+      method = data[0]
+      value = data[1]
+      send_value(target, method, value)
+    end
+
+    private
+
+    def send_value(target, method, value = nil)
+      method = method.to_s
+      return nil unless target_has_method?(target, method)
+      return target.send(method) unless value.present?
+      return target.send(method, *value) if value.instance_of?(Array)
+      target.send(method, value)
+    end
+
+    def target_has_method?(target, method)
+      target.methods.include?(method.to_sym)
+    end
+
+    def parse_method(target, method)
+      self.class.parse(target, method)
+    end
+  end
+end

data/lib/reportinator/parsers/value.rb

@@ -0,0 +1,144 @@
+module Reportinator
+  class ValueParser < Base
+    VALUE_FUNCTIONS = %i[a d n rn rd r]
+
+    attribute :element
+    attribute :variables, default: {}
+
+    def self.parse(element, variables = {})
+      variables = variables.present? ? variables : {}
+      new(element: element, variables: variables).output
+    end
+
+    def self.parse_and_execute(target, values, variables = {})
+      parsed_target = target
+      if target.instance_of?(String)
+        parsed_target = new(element: target, variables: variables).parse_string
+      end
+      parsed_values = parse(values, variables)
+      MethodParser.parse(parsed_target, parsed_values)
+    end
+
+    def output
+      return parse_array if element_class == Array
+      return parse_hash if element_class == Hash
+      return parse_string if element_class == String
+      element
+    end
+
+    def parse_array
+      raise "Not an array" unless element_class == Array
+      front = element[0]
+      return parse_executed_array if front.instance_of?(String) && front.start_with?("#")
+      element.map { |value| parse_value(value) }
+    end
+
+    def parse_executed_array
+      raise "Not an executable array" unless element[0].start_with?("#")
+      values = element
+      target = values.delete_at(0).sub("#", "")
+      parse_and_execute_value(target, values)
+    end
+
+    def parse_hash
+      raise "Not a hash" unless element_class == Hash
+      element.transform_values { |value| parse_value(value) }
+    end
+
+    def parse_string
+      raise "Not a string" unless element_class == String
+      return element.sub(":", "").to_sym if element.start_with?(":")
+      return element.sub("&", "").constantize if element.start_with?("&")
+      return parse_variable(element) if element.start_with?("$")
+      return parse_function(element) if element.start_with?("!")
+      element
+    end
+
+    def element_class
+      element.class
+    end
+
+    private
+
+    def parse_variable(value)
+      key = value.sub("$", "").to_sym
+      variables[key]
+    end
+
+    def parse_function(value)
+      input = value.strip
+      function = function_type(input)
+      return value unless function.present?
+      input.sub!(function_prefix(function), "")
+      output = run_function(function, input)
+      output.nil? ? value : output
+    end
+
+    def run_function(function, input)
+      case function
+      when :a then addition_function(input)
+      when :d then date_function(input)
+      when :n then number_function(input)
+      when :r then range_function(input)
+      when :rn then range_function(input, :number)
+      when :rd then range_function(input, :date)
+      end
+    end
+
+    def function_type(value)
+      VALUE_FUNCTIONS.each do |function|
+        return function if value.start_with?(function_prefix(function))
+      end
+      false
+    end
+
+    def function_prefix(function)
+      "!#{function}"
+    end
+
+    def addition_function(value)
+      values = parse_function_array(value)
+      values.map! { |value| number_function(value) }
+      values.sum(0)
+    rescue
+      0
+    end
+
+    def date_function(value)
+      Time.parse(value)
+    rescue
+      Time.now
+    end
+
+    def number_function(value)
+      float = (value =~ /\d\.\d/)
+      return value.to_f if float.present?
+      value.to_i
+    rescue
+      0
+    end
+
+    def range_function(value, type = :any)
+      values = parse_function_array(value)
+      case type
+      when :number then values.map! { |subvalue| number_function(subvalue) }
+      when :date then values.map! { |subvalue| date_function(subvalue) }
+      end
+      Range.new(*values)
+    rescue
+      Range(0..1)
+    end
+
+    def parse_function_array(value)
+      value.split(",").map { |value| parse_value(value.strip) }
+    end
+
+    def parse_value(value)
+      self.class.parse(value, variables)
+    end
+
+    def parse_and_execute_value(target, value)
+      self.class.parse_and_execute(target, value, variables)
+    end
+  end
+end

data/lib/reportinator/report.rb

@@ -0,0 +1,51 @@
+module Reportinator
+  class Report < Base
+    attribute :title
+
+    def self.generate(params)
+      output = {}
+      params.each do |key, value|
+        raise "Missing hash!" unless value.instance_of?(Hash)
+        value[:name] ||= key
+        output[key] = new(value).data
+      end
+      output
+    end
+
+    def self.generate_to_csv(params)
+      params.each do |key, value|
+        raise "Missing hash!" unless value.instance_of?(Hash)
+        value[:name] ||= key
+        report = new(value)
+        csv = report.generate_csv
+        puts "Report generated to #{csv}"
+      end
+      true
+    end
+
+    def report_title
+      return nil unless title.present?
+      parsed_title = ValueParser.parse(title)
+      parsed_title = parsed_title.join if parsed_title.instance_of?(Array)
+      parsed_title
+    end
+
+    def generate_csv(path)
+      write_to_csv(path, data)
+    end
+
+    def error_message
+      errors.full_messages.to_s
+    end
+
+    private
+
+    def write_to_csv(path, data)
+      return path if File.exist?(path)
+      CSV.open(path, "wb") do |csv|
+        data.each { |row| csv << row }
+      end
+      path
+    end
+  end
+end

data/lib/reportinator/types/model.rb

@@ -0,0 +1,30 @@
+module Reportinator
+  class ModelReport < Report
+    attribute :target
+    attribute :method_list, default: []
+
+    validates :target, presence: true
+
+    def data
+      return get_model_data(target) unless target.methods.include? :first
+      records_data
+    end
+
+    def records_data
+      records = target
+      records = target.all if target.methods.include? :all
+      output = []
+      records.each do |model|
+        value = get_model_data(model)
+        output << value
+      end
+      output
+    end
+
+    def get_model_data(target)
+      method_list.map do |method|
+        ValueParser.parse_and_execute(target, method)
+      end
+    end
+  end
+end

data/lib/reportinator/types/preset.rb

@@ -0,0 +1,5 @@
+module Reportinator
+  class PresetReport < Report
+    attribute :data, default: []
+  end
+end

data/lib/reportinator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Reportinator
+  VERSION = "0.1.0"
+end

data/lib/reportinator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "reportinator/version"
+require "csv"
+require "json"
+require "fileutils"
+require "active_support"
+require "active_model"
+require "require_all"
+
+module Reportinator
+  class Error < StandardError; end
+  class << self
+    attr_writer :config
+    attr_writer :logger
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure
+    yield(config)
+  end
+
+  def self.logger
+    @logger || ActiveSupport::Logger.new($stdout)
+  end
+
+  def self.report(template, additional_params = {})
+    Loader.data_from_template(template, additional_params)
+  end
+
+  def self.output(template, additional_params = {}, filename = "")
+    filename = (filename.present? ? filename : "#{template}.csv")
+    path = "#{config.output_directory}/#{filename}"
+    FileUtils.mkdir_p(File.dirname(path))
+    data = Loader.data_from_template(template, additional_params)
+    CSV.open(path, "wb") do |csv|
+      data.each do |row|
+        csv << row
+      end
+    end
+    path
+  end
+
+  class Base
+    include ActiveModel::API
+    include ActiveModel::Attributes
+
+    require_all "lib/reportinator"
+
+    def self.config
+      Reportinator.config
+    end
+
+    def config
+      self.class.config
+    end
+
+    def self.logger
+      Reportinator.logger
+    end
+
+    def logger
+      self.class.logger
+    end
+  end
+end

data/sig/reportinator.rbs

@@ -0,0 +1,4 @@
+module Reportinator
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: reportinator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Moxvallix
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Behold! My Reportinator! Reportinator makes reports from JSON files.
+email:
+- dev@moxvallix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".standard.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/reports/example.report.json
+- app/reports/multiplication.report.json
+- lib/reportinator.rb
+- lib/reportinator/config.rb
+- lib/reportinator/loader.rb
+- lib/reportinator/parsers/method.rb
+- lib/reportinator/parsers/value.rb
+- lib/reportinator/report.rb
+- lib/reportinator/types/model.rb
+- lib/reportinator/types/preset.rb
+- lib/reportinator/version.rb
+- sig/reportinator.rbs
+homepage: https://github.com/moxvallix/reportinator
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/moxvallix/reportinator
+  source_code_uri: https://github.com/moxvallix/reportinator
+  changelog_uri: https://github.com/moxvallix/reportinator
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Easily generate reports using a JSON template.
+test_files: []