nocode 0.0.0 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1118aa168a7f6135326ca4479e6c3ce85c366ef0e9c280ec2ac96f242a25c717
-  data.tar.gz: 054200f0d28e69a9b725c9ecc0a34f78e09f8a610e3b66f11d64cd7455b41217
+  metadata.gz: 884ab5737629463437ef0991555e1ea30faa8db0cd6d8c79da712942aa69011b
+  data.tar.gz: d8562fdf11b2a204e9ced685b434d6959bafe2dca605dd3795355aeed1ed5238
 SHA512:
-  metadata.gz: df2518dc919e0fd84eac03c97b77f27fc125bfcea83f17dd786d0539c4907e093f2ede6f3c0c636c3033e4f515aa7c4a06c982f782c3a149286b2eed0deec7f3
-  data.tar.gz: b736b5e447a1445dda04245f6d1a86f481d818e71f16f67b850705ad1efcf937ab4db154cb0abfdcbd2bded999a21164fc5ff6f8a29c2aff2ead40a2d1af29ba
+  metadata.gz: 677aa00aba3a998a4cc616002420c9366ac945fabdfc336d948b5158c24eae6c9bfc1b8a7ee658718c5c55af4148c4f83656fddf8b45995002471ef7224870da
+  data.tar.gz: e4de53676eaebb1d9bd3738dbbbb6df777ce0fdf1674e9aa370176c2eca9d42d4672d6edd682a313b943f24d149566491d1d7322d9c30ed0cc352db7730e0f3f

data/.github/workflows/rubygem.yml

@@ -8,7 +8,6 @@ on:
 
 jobs:
   test:
-
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -26,3 +25,5 @@ jobs:
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
     - name: Run tests
       run: bundle exec rake
+    - name: Security audit dependencies
+      run: bundle exec bundler-audit check --update

data/.rubocop.yml

@@ -6,8 +6,13 @@ AllCops:
   NewCops: enable
   TargetRubyVersion: 2.6
 
+Metrics/BlockLength:
+  Max: 30
+  IgnoredMethods:
+    - describe
+
 Metrics/MethodLength:
   Max: 20
 
-Style/Documentation:
-  Enabled: false
+RSpec/ExampleLength:
+  Max: 10

data/CHANGELOG.md

@@ -1,3 +1,12 @@
-#### February 9th, 2022
+#### 0.0.4 - February 13th, 2022
+
+* Increase class documentation
+* Add YAML serialization/deserializationß
+
+#### 0.0.3 - February 12th, 2022
+
+* Add initial implementation.
+
+#### 0.0.0 - February 9th, 2022
 
 * Establish initial repository and gem infrastructure.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,73 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers 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, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported. All complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/README.md

@@ -1,11 +1,127 @@
 # Nocode
 
-## Execute Ruby code through YAML
+#### Execute Ruby code through YAML
 
-**Warning**: This library is currently experimental.
+[![Gem Version](https://badge.fury.io/rb/nocode.svg)](https://badge.fury.io/rb/nocode) [![Ruby Gem CI](https://github.com/mattruggio/nocode/actions/workflows/rubygem.yml/badge.svg)](https://github.com/mattruggio/nocode/actions/workflows/rubygem.yml)
 
----
+This is a proof of concept showing how a YAML interface could be draped over arbitrary Ruby code.  The YAML contains a series of steps with each step mapping to a specific Ruby class.  The Ruby classes just have one responsibility: to implement #perform.
 
-[![Ruby Gem CI](https://github.com/mattruggio/nocode/actions/workflows/rubygem.yml/badge.svg)](https://github.com/mattruggio/nocode/actions/workflows/rubygem.yml)
+## Installation
 
-This is a proof of concept showing how a YAML interface could be draped over arbitrary Ruby code.  The YAML contains a series of steps with each step mapping to a specific Ruby class.  The Ruby classes just have one responsibility: to implement #perform.
+To install through Rubygems:
+
+````
+gem install nocode
+````
+
+You can also add this to your Gemfile using:
+
+````
+bundle add nocode
+````
+
+## Examples
+
+Create a file called `nocode-csv-to-json.yaml`:
+
+### CSV-to-JSON File Converter
+
+````yaml
+parameters:
+  input_filename: input.csv
+  output_filename: output.json
+
+steps:
+  - type: io/read
+    name: READ FILE
+    options:
+      path:
+        - files
+        - << parameters.input_filename >>
+  - type: deserialize/csv
+  - type: serialize/json
+  - type: io/write
+    options:
+      path:
+        - files
+        - << parameters.output_filename >>
+````
+
+Create csv file at: `files/input.csv`
+
+Execute in Ruby:
+
+````ruby
+path = Pathname.new('nocode-csv-to-json.yaml')
+
+Nocode.execute(path)
+````
+
+Or use bundler:
+
+````zsh
+bundle exec nocode `nocode-csv-to-json.yaml
+````
+
+A file should have been created at: `files/output.json`.
+
+Notes:
+
+* Path can be an array or a string.  If its an array then the environment's path separator will be used.
+* The `name` job key is optional.  If present then it will print out on the log.
+* Parameter values can be interpolated with keys and values using `<< parameters.key >>` syntax
+
+
+
+## Contributing
+
+### Development Environment Configuration
+
+Basic steps to take to get this repository compiling:
+
+1. Install [Ruby](https://www.ruby-lang.org/en/documentation/installation/) (check nocode.gemspec for versions supported)
+2. Install bundler (gem install bundler)
+3. Clone the repository (git clone git@github.com:mattruggio/nocode.git)
+4. Navigate to the root folder (cd nocode)
+5. Install dependencies (bundle)
+
+### Running Tests
+
+To execute the test suite run:
+
+````bash
+bundle exec rspec spec --format documentation
+````
+
+Alternatively, you can have Guard watch for changes:
+
+````bash
+bundle exec guard
+````
+
+Also, do not forget to run Rubocop:
+
+````bash
+bundle exec rubocop
+````
+
+### Publishing
+
+Note: ensure you have proper authorization before trying to publish new versions.
+
+After code changes have successfully gone through the Pull Request review process then the following steps should be followed for publishing new versions:
+
+1. Merge Pull Request into main
+2. Update `version.rb` using [semantic versioning](https://semver.org/)
+3. Install dependencies: `bundle`
+4. Update `CHANGELOG.md` with release notes
+5. Commit & push main to remote and ensure CI builds main successfully
+6. Run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Code of Conduct
+
+Everyone interacting in this codebase, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/mattruggio/nocode/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+This project is MIT Licensed.

data/exe/nocode

@@ -11,4 +11,4 @@ if path.to_s.empty?
   exit
 end
 
-puts '<Implementation goes here>'
+Nocode.execute(Pathname.new(path))

data/lib/nocode/context.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Nocode
+  # Describes the environment for each running step.  An instance is initialized when a job
+  # kicks off and then is passed from step to step.
+  class Context
+    attr_reader :io, :parameters, :registers
+
+    def initialize(io: $stdout, parameters: {}, registers: {})
+      @io         = io || $stdout
+      @parameters = Util::Dictionary.ensure(parameters)
+      @registers  = Util::Dictionary.ensure(registers)
+
+      freeze
+    end
+
+    def register(key)
+      registers[key]
+    end
+
+    def parameter(key)
+      parameters[key]
+    end
+
+    def to_h
+      {
+        'registers' => registers,
+        'parameters' => parameters
+      }
+    end
+  end
+end

data/lib/nocode/executor.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'context'
+require_relative 'step_registry'
+
+module Nocode
+  # Manages the lifecycle and executes a job.
+  class Executor
+    attr_reader :yaml, :io
+
+    def initialize(yaml, io: $stdout)
+      @yaml = yaml.respond_to?(:read) ? yaml.read : yaml
+      @yaml = YAML.safe_load(@yaml) || {}
+      @io   = io
+
+      freeze
+    end
+
+    def execute
+      steps      = yaml['steps'] || []
+      parameters = yaml['parameters'] || {}
+      context    = Context.new(io: io, parameters: parameters)
+
+      log_title
+
+      steps.each do |step|
+        step_instance = make_step(step, context)
+
+        execute_step(step_instance)
+      end
+
+      log("Ended: #{DateTime.now}")
+      log_line
+
+      context
+    end
+
+    private
+
+    def make_step(step, context)
+      step       = Util::ObjectTemplate.new(step).evaluate(context.to_h)
+      type       = step['type'].to_s
+      name       = step['name'].to_s
+      options    = step['options'] || {}
+      step_class = StepRegistry.constant!(type)
+
+      step_class.new(
+        options: Util::Dictionary.new(options),
+        context: context,
+        name: name,
+        type: type
+      )
+    end
+
+    def execute_step(step)
+      log(step.name) unless step.name.empty?
+      log("Step:  #{step.type}")
+      log("Class: #{step.class}")
+
+      time_in_seconds = Benchmark.measure { step.perform }.real
+
+      log("Completed in #{time_in_seconds.round(3)} second(s)")
+
+      log_line
+    end
+
+    def log_title
+      log_line
+
+      log('Nocode Execution')
+      log("Started: #{DateTime.now}")
+
+      log_line
+    end
+
+    def log_line
+      log('-' * 50)
+    end
+
+    def log(msg)
+      io.puts(msg)
+    end
+  end
+end

data/lib/nocode/step.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Nocode
+  # Defines a running step.  Steps should be sub-classes of this class as well as to implement
+  # #perform.
+  class Step
+    extend Forwardable
+    include Util::Arrayable
+    include Util::Optionable
+
+    attr_reader :context,
+                :name,
+                :options,
+                :type
+
+    def_delegators :context,
+                   :io,
+                   :parameters,
+                   :registers
+
+    def initialize(
+      context: Context.new,
+      name: '',
+      options: {},
+      type: ''
+    )
+      @context = context
+      @options = options
+      @name    = name
+      @type    = type
+    end
+  end
+end

data/lib/nocode/step_registry.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'step'
+
+# This will execute the StepRegisty's load! method upon script evaluation.
+module Nocode
+  # Provides a global place to register all valid steps by their types.  By default the
+  # steps directory will be autoloaded and their paths will be used as their types.  For example:
+  # for the class: steps/io/write, it would register as "io/write" type.
+  class StepRegistry < Util::ClassRegistry
+    include Singleton
+
+    PREFIX = 'Nocode::Steps::'
+    DIR    = File.join(__dir__, 'steps')
+
+    class << self
+      extend Forwardable
+
+      def_delegators :instance,
+                     :register,
+                     :constant!,
+                     :add,
+                     :load!
+    end
+
+    def load!
+      files_loaded = Util::ClassLoader.new(DIR).load!
+
+      # Class the parent to load up the registry with the files we found.
+      load(files_loaded, PREFIX)
+    end
+  end
+
+  # Call upon class evaluation to autoload all classes.
+  StepRegistry.load!
+end

data/lib/nocode/steps/copy.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    # Shallow-copy one register to another.
+    class Copy < Step
+      option :from_register, :to_register
+
+      def perform
+        registers[to_register_option] = registers[from_register_option].dup
+      end
+    end
+  end
+end

data/lib/nocode/steps/delete.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    # Remove a register completely.
+    class Delete < Step
+      option :register
+
+      def perform
+        registers.delete(register_option)
+      end
+    end
+  end
+end

data/lib/nocode/steps/deserialize/csv.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Deserialize
+      # take a specified register and parse it as a CSV to produce an array of hashes.
+      class Csv < Step
+        option :register
+
+        def perform
+          input = registers[register_option].to_s
+
+          registers[register_option] = CSV.new(input, headers: true).map(&:to_h)
+        end
+      end
+    end
+  end
+end

data/lib/nocode/steps/deserialize/json.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Deserialize
+      # take a specified register and parse it as JSON to produce Ruby object(s).
+      class Json < Step
+        option :register
+
+        def perform
+          input = registers[register_option]
+
+          registers[register_option] = JSON.parse(input)
+        end
+      end
+    end
+  end
+end

data/lib/nocode/steps/deserialize/yaml.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Deserialize
+      # Take a specified register and parse it as YAML to produce Ruby object(s).
+      #
+      # NOTE: This will throw an error if unsafe YAML types are used.  The only allowed types are
+      # array, hash, strings, numbers, booleans, nil.  See:
+      # https://ruby-doc.org/stdlib-2.6.1/libdoc/psych/rdoc/Psych.html#method-c-safe_load
+      class Yaml < Step
+        option :register
+
+        def perform
+          input = registers[register_option]
+
+          registers[register_option] = YAML.safe_load(input)
+        end
+      end
+    end
+  end
+end

data/lib/nocode/steps/io/read.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Io
+      # Read a file from disk and place its contents in a register.
+      class Read < Step
+        option :path,
+               :register
+
+        def perform
+          data = File.read(path)
+
+          registers[register_option] = data
+        end
+
+        private
+
+        def path
+          File.join(*array(path_option))
+        end
+      end
+    end
+  end
+end

data/lib/nocode/steps/io/write.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Io
+      # Write the contents of a register to disk.
+      class Write < Step
+        option :path,
+               :register
+
+        def perform
+          data = registers[register_option]
+
+          FileUtils.mkdir_p(File.dirname(path))
+
+          File.write(path, data)
+        end
+
+        private
+
+        def path
+          File.join(*array(path_option))
+        end
+      end
+    end
+  end
+end

data/lib/nocode/steps/log.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    # Simply output the passed in message into the outputted log.
+    class Log < Step
+      option :message
+
+      def perform
+        io.puts(message_option.to_s)
+      end
+    end
+  end
+end

data/lib/nocode/steps/serialize/csv.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Serialize
+      # Take the contents of a register and create a CSV out of its contents.  The CSV contents
+      # will override the register specified.
+      class Csv < Step
+        option :register
+
+        def perform
+          input = registers[register_option]
+
+          registers[register_option] = CSV.generate do |csv|
+            array(input).each_with_index do |object, index|
+              csv << object.keys if index.zero? && object.respond_to?(:keys)
+
+              add_object(object, csv)
+            end
+          end
+        end
+
+        private
+
+        def add_object(object, csv)
+          object ||= {}
+
+          if object.is_a?(Array)
+            csv << object
+
+            true
+          elsif object.respond_to?(:values)
+            csv << object.values
+
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nocode/steps/serialize/json.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Serialize
+      # Take the contents of a register and serialize it as JSON.  The serialized JSON
+      # will override the register specified.
+      class Json < Step
+        option :register
+
+        def perform
+          input = registers[register_option]
+
+          registers[register_option] = input.to_json
+        end
+      end
+    end
+  end
+end

data/lib/nocode/steps/serialize/yaml.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Serialize
+      # Take the contents of a register and serialize it as YAML.  The serialized YAML
+      # will override the register specified.
+      class Yaml < Step
+        option :register
+
+        def perform
+          input = registers[register_option]
+
+          registers[register_option] = input.to_yaml
+        end
+      end
+    end
+  end
+end

data/lib/nocode/steps/set.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    # Set a register's value to the value option specified.
+    class Set < Step
+      option :register, :value
+
+      def perform
+        registers[register_option] = value_option
+      end
+    end
+  end
+end

data/lib/nocode/steps/sleep.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    # Sleep for an arbitrary number of seconds.
+    class Sleep < Step
+      option :seconds
+
+      def perform
+        Kernel.sleep(seconds_option.to_f)
+      end
+    end
+  end
+end

data/lib/nocode/util/arrayable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    # Hand
+    module Arrayable
+      def array(value)
+        if value.is_a?(Hash)
+          [value]
+        else
+          Array(value)
+        end
+      end
+    end
+  end
+end

data/lib/nocode/util/class_loader.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    # Loads a directory full of Ruby classes and returns their relative paths.
+    class ClassLoader
+      EXTENSION = '.rb'
+
+      attr_reader :dir
+
+      def initialize(dir)
+        @dir = dir
+
+        freeze
+      end
+
+      def load!
+        Dir[File.join(dir, '**', "*#{EXTENSION}")].sort.map do |step_path|
+          require step_path
+
+          step_path
+            .delete_prefix(dir)
+            .delete_prefix(File::SEPARATOR)
+            .delete_suffix(EXTENSION)
+        end
+      end
+    end
+  end
+end

data/lib/nocode/util/class_registry.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    # Create a type -> class constant interface.  Classes can be registered as types.  Types
+    # are snake-cased while class names are stored as pascal-cased.  Then constant! can be called
+    # to retrieve the class constant by type.
+    class ClassRegistry
+      extend Forwardable
+
+      class NotRegisteredError < StandardError; end
+
+      attr_reader :types_to_classes
+
+      def_delegators :types_to_classes, :to_s
+
+      def initialize(types_to_classes = {})
+        @types_to_classes = Dictionary.new(types_to_classes)
+
+        freeze
+      end
+
+      def load(types, prefix = '')
+        types.each do |type|
+          pascal_cased = type.split(File::SEPARATOR).map do |part|
+            part.split('_').collect(&:capitalize).join
+          end.join('::')
+
+          register(type, "#{prefix}#{pascal_cased}")
+        end
+
+        self
+      end
+
+      def register(type, class_name)
+        tap { types_to_classes[type] = class_name }
+      end
+
+      def unregister(type)
+        tap { types_to_classes.delete(type) }
+      end
+
+      def constant!(type)
+        name = types_to_classes[type]
+
+        raise NotRegisteredError, "Constant not registered for: #{type}" if name.to_s.empty?
+
+        if Object.const_defined?(name, false)
+          Object.const_get(name, false)
+        else
+          Object.const_missing(name)
+        end
+      end
+    end
+  end
+end

data/lib/nocode/util/dictionary.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    # A hash-like object which ensures all keys are strings.
+    class Dictionary
+      extend Forwardable
+
+      NEWLINE_CHAR = "\n"
+
+      class << self
+        def ensure(value)
+          if value.is_a?(self)
+            value
+          else
+            new(value)
+          end
+        end
+      end
+
+      attr_reader :values
+
+      def_delegators :values, :empty?
+
+      def initialize(values = {})
+        @values = {}
+
+        (values || {}).each { |k, v| assign(k, v) }
+
+        freeze
+      end
+
+      def delete(key)
+        tap { values.delete(keyify(key)) }
+      end
+
+      def []=(key, value)
+        tap { values[keyify(key)] = value }
+      end
+
+      def [](key)
+        values[keyify(key)]
+      end
+
+      def dig(*keys)
+        top_level = keyify(keys.first)
+        keys = [top_level] + keys[1..]
+
+        values.dig(*keys)
+      end
+
+      def key?(key)
+        values.key?(keyify(key))
+      end
+
+      def to_s
+        values.map { |k, v| "#{k}: #{v}" }.join(NEWLINE_CHAR)
+      end
+
+      private
+
+      def assign(key, value)
+        values[keyify(key)] = value
+      end
+
+      def keyify(value)
+        value.to_s
+      end
+    end
+  end
+end

data/lib/nocode/util/object_template.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'string_template'
+
+module Nocode
+  module Util
+    # Built on top of StringTemplate but instead of only working for a string, this will
+    # recursively evaluate all strings within an object.  Heuristics:
+    #    - Strings evaluate using StringTemplate
+    #    - Hashes will have their keys and values traversed
+    #    - Arrays will have their entries traversed
+    #    - All other types will simply return themselves
+    class ObjectTemplate
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+
+        freeze
+      end
+
+      def evaluate(values = {})
+        recursive_evaluate(object, values)
+      end
+
+      private
+
+      def recursive_evaluate(expression, values)
+        case expression
+        when Array
+          expression.map { |o| recursive_evaluate(o, values) }
+        when Hash
+          expression.to_h do |k, v|
+            [recursive_evaluate(k, values), recursive_evaluate(v, values)]
+          end
+        when String
+          Util::StringTemplate.new(expression).evaluate(values)
+        else
+          expression
+        end
+      end
+    end
+  end
+end

data/lib/nocode/util/optionable.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    # Add on a DSL for classes.  The DSL allows for a new class-level keyword called 'option'
+    # which can be used to describe what metadata values are important.  Then instances
+    # can reference those option's values using magic _option methods.  For example:
+    #
+    # class Animal
+    #   include Optionable
+    #   option :type
+    #   attr_writer :options
+    # end
+    #
+    # animal = Animal.new
+    # animal.options = { 'type' => 'dog' }
+    #
+    # animal.type_option # -> should return 'dog'
+    module Optionable
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      # Class-level DSL Methods
+      module ClassMethods
+        def option(*values)
+          values.each { |v| options << v.to_s }
+        end
+
+        def options
+          @options ||= []
+        end
+      end
+
+      OPTION_PREFIX = '_option'
+
+      def options
+        @options || {}
+      end
+
+      def method_missing(name, *args, &block)
+        key = option_key(name)
+
+        if name.to_s.end_with?(OPTION_PREFIX) && self.class.options.include?(key)
+          options[key]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        key = option_key(name)
+
+        (name.to_s.end_with?(OPTION_PREFIX) && self.class.options.include?(key)) || super
+      end
+
+      private
+
+      def option_key(name)
+        name.to_s.gsub(OPTION_PREFIX, '')
+      end
+    end
+  end
+end

data/lib/nocode/util/string_template.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    # Takes in an expression and interpolates in any parameters using << >> notation.
+    # For example:
+    #   input = { 'person' => 'hops' }
+    #   Nocode::Util::StringTemplate.new("Hello, << person.name >>!").evaluate(input)
+    # Should produce: "Hello, hops!"
+    class StringTemplate
+      LEFT_TOKEN  = '<<'
+      RIGHT_TOKEN = '>>'
+      SEPARATOR   = '.'
+      REG_EXPR    = /#{Regexp.quote(LEFT_TOKEN)}(.*?)#{Regexp.quote(RIGHT_TOKEN)}/.freeze
+
+      attr_reader :expression
+
+      def initialize(expression)
+        @expression = expression.to_s
+
+        freeze
+      end
+
+      def evaluate(values = {})
+        resolved = tokens_to_values(tokens, values)
+
+        tokens.inject(expression) do |memo, token|
+          memo.gsub("#{LEFT_TOKEN}#{token}#{RIGHT_TOKEN}", resolved[token].to_s)
+        end
+      end
+
+      private
+
+      def tokens
+        expression.to_s.scan(REG_EXPR).flatten
+      end
+
+      def tokens_to_values(tokens, values)
+        tokens.each_with_object({}) do |token, memo|
+          cleansed = token.strip
+          parts    = cleansed.split(SEPARATOR)
+          value    = values.dig(*parts)
+
+          memo[token] = value
+        end
+      end
+    end
+  end
+end

data/lib/nocode/util.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'util/arrayable'
+require_relative 'util/class_loader'
+require_relative 'util/class_registry'
+require_relative 'util/dictionary'
+require_relative 'util/object_template'
+require_relative 'util/optionable'

data/lib/nocode/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nocode
-  VERSION = '0.0.0'
+  VERSION = '0.0.4'
 end

data/lib/nocode.rb

@@ -1,4 +1,25 @@
 # frozen_string_literal: true
 
+require 'benchmark'
+require 'csv'
+require 'fileutils'
+require 'json'
+require 'singleton'
+require 'time'
+require 'yaml'
+
+# Util
+require 'nocode/util'
+
+# Core
+require 'nocode/executor'
+
+# Establish main top-level namespace
 module Nocode
+  # Default consumer entrypoint into the library.
+  class << self
+    def execute(yaml, io: $stdout)
+      Executor.new(yaml, io: io).execute
+    end
+  end
 end

data/nocode.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 2.6'
 
+  s.add_development_dependency('bundler-audit')
   s.add_development_dependency('guard-rspec')
   s.add_development_dependency('pry')
   s.add_development_dependency('rake')

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: nocode
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.4
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-09 00:00:00.000000000 Z
+date: 2022-02-13 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  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: guard-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -151,16 +165,40 @@ files:
 - ".rubocop.yml"
 - ".tool-versions"
 - CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - Gemfile
 - Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - bin/console
-- bin/rspec
-- bin/rubocop
 - exe/nocode
 - lib/nocode.rb
+- lib/nocode/context.rb
+- lib/nocode/executor.rb
+- lib/nocode/step.rb
+- lib/nocode/step_registry.rb
+- lib/nocode/steps/copy.rb
+- lib/nocode/steps/delete.rb
+- lib/nocode/steps/deserialize/csv.rb
+- lib/nocode/steps/deserialize/json.rb
+- lib/nocode/steps/deserialize/yaml.rb
+- lib/nocode/steps/io/read.rb
+- lib/nocode/steps/io/write.rb
+- lib/nocode/steps/log.rb
+- lib/nocode/steps/serialize/csv.rb
+- lib/nocode/steps/serialize/json.rb
+- lib/nocode/steps/serialize/yaml.rb
+- lib/nocode/steps/set.rb
+- lib/nocode/steps/sleep.rb
+- lib/nocode/util.rb
+- lib/nocode/util/arrayable.rb
+- lib/nocode/util/class_loader.rb
+- lib/nocode/util/class_registry.rb
+- lib/nocode/util/dictionary.rb
+- lib/nocode/util/object_template.rb
+- lib/nocode/util/optionable.rb
+- lib/nocode/util/string_template.rb
 - lib/nocode/version.rb
 - nocode.gemspec
 homepage: https://github.com/mattruggio/nocode

data/bin/rspec

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'rspec' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require 'pathname'
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
-                                           Pathname.new(__FILE__).realpath)
-
-bundle_binstub = File.expand_path('bundle', __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require 'rubygems'
-require 'bundler/setup'
-
-load Gem.bin_path('rspec-core', 'rspec')

data/bin/rubocop

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'rubocop' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require 'pathname'
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
-                                           Pathname.new(__FILE__).realpath)
-
-bundle_binstub = File.expand_path('bundle', __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require 'rubygems'
-require 'bundler/setup'
-
-load Gem.bin_path('rubocop', 'rubocop')