nocode 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1118aa168a7f6135326ca4479e6c3ce85c366ef0e9c280ec2ac96f242a25c717
-  data.tar.gz: 054200f0d28e69a9b725c9ecc0a34f78e09f8a610e3b66f11d64cd7455b41217
+  metadata.gz: e3f1a62969f19767ac717993632a0d51785969482b172c6e33cbfc94cfd13ce3
+  data.tar.gz: 76e62efa73b9d7489cea1bb7825df6ed490439de097f3b3abb404a8f74f98d63
 SHA512:
-  metadata.gz: df2518dc919e0fd84eac03c97b77f27fc125bfcea83f17dd786d0539c4907e093f2ede6f3c0c636c3033e4f515aa7c4a06c982f782c3a149286b2eed0deec7f3
-  data.tar.gz: b736b5e447a1445dda04245f6d1a86f481d818e71f16f67b850705ad1efcf937ab4db154cb0abfdcbd2bded999a21164fc5ff6f8a29c2aff2ead40a2d1af29ba
+  metadata.gz: f64bfa9cc952d58d9a5d37c5ac1045fae4e5b63d1f9bac5f5ac2522420790dc0003b878e52c009bc275960acf39732ccfd65a9d3c68d223954bd4ff56ba30eb7
+  data.tar.gz: 317d4ef406a064b2160247475a30911eaed26ac8d009a435c3ec9abe95ee91d64a88729a7146d3e19f7ab719e405b69b42dcaddf2fa928e0ef9d9fa014574b47

data/.github/workflows/rubygem.yml

@@ -8,7 +8,6 @@ on:
 
 jobs:
   test:
-
     runs-on: ubuntu-latest
     strategy:
       matrix:

data/.rubocop.yml

@@ -6,8 +6,16 @@ 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/README.md

@@ -1,11 +1,9 @@
 # Nocode
 
-## Execute Ruby code through YAML
-
-**Warning**: This library is currently experimental.
-
----
+#### Execute Ruby code through YAML
 
 [![Ruby Gem CI](https://github.com/mattruggio/nocode/actions/workflows/rubygem.yml/badge.svg)](https://github.com/mattruggio/nocode/actions/workflows/rubygem.yml)
 
+**Warning**: This library is currently experimental.
+
 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.

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,30 @@
+# frozen_string_literal: true
+
+module Nocode
+  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 'options_template'
+require_relative 'step_registry'
+
+module Nocode
+  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)
+      type             = step['type'].to_s
+      name             = step['name'].to_s
+      options          = step['options'] || {}
+      compiled_options = OptionsTemplate.new(options).evaluate(context.to_h)
+      step_class       = StepRegistry.constant!(type)
+
+      step_class.new(
+        options: Util::Dictionary.new(compiled_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/options_template.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Nocode
+  class OptionsTemplate
+    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

data/lib/nocode/step.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Nocode
+  class Step
+    extend Forwardable
+    include Util::Arrayable
+    include Util::Optionable
+
+    attr_reader :name, :context, :options, :type
+
+    def_delegators :context, :parameters, :registers, :io
+
+    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,30 @@
+# frozen_string_literal: true
+
+require_relative 'step'
+
+module Nocode
+  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!
+
+      load(files_loaded, PREFIX)
+    end
+  end
+
+  StepRegistry.load!
+end

data/lib/nocode/steps/copy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    class Copy < Step
+      option :from_register, :to_register
+
+      def perform
+        registers[to_register_option] = registers[from_register_option]
+      end
+    end
+  end
+end

data/lib/nocode/steps/delete.rb

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

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Io
+      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,26 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    module Io
+      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,13 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    class Log < Step
+      option :message
+
+      def perform
+        io.puts(message_option.to_s)
+      end
+    end
+  end
+end

data/lib/nocode/steps/set.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    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,13 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Steps
+    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,15 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    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,28 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    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,53 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    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,70 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    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/optionable.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    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,44 @@
+# frozen_string_literal: true
+
+module Nocode
+  module Util
+    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
+
+        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/optionable'
+require_relative 'util/string_template'

data/lib/nocode/version.rb

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

data/lib/nocode.rb

@@ -1,4 +1,21 @@
 # frozen_string_literal: true
 
+require 'benchmark'
+require 'fileutils'
+require 'singleton'
+require 'time'
+require 'yaml'
+
+# Util
+require 'nocode/util'
+
+# Core
+require 'nocode/executor'
+
 module Nocode
+  class << self
+    def execute(yaml, io: $stdout)
+      Executor.new(yaml, io: io).execute
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nocode
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 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: guard-rspec
@@ -157,10 +157,27 @@ files:
 - README.md
 - Rakefile
 - bin/console
-- bin/rspec
-- bin/rubocop
 - exe/nocode
 - lib/nocode.rb
+- lib/nocode/context.rb
+- lib/nocode/executor.rb
+- lib/nocode/options_template.rb
+- lib/nocode/step.rb
+- lib/nocode/step_registry.rb
+- lib/nocode/steps/copy.rb
+- lib/nocode/steps/delete.rb
+- lib/nocode/steps/io/read.rb
+- lib/nocode/steps/io/write.rb
+- lib/nocode/steps/log.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/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')