hollerith 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e3353a0f5cf501d7eddbc88d38e1f2e96167a6eb5b862f888a4ca8842e5a301f
+  data.tar.gz: 0991414ad5bc0a26004f6418594d4d0e1e659d87ba4a0f34e3c0e7a37063da64
+SHA512:
+  metadata.gz: 5f31d9d1b552c06a62663d5cad8b99f21d18ea68aa90f234f9d8a17fef7db1b1b64f9664dde621f584fa42ecba85123c111c49a57b429c37c0b544eddcf21b03
+  data.tar.gz: 862b4222af98f74c3895bf832e215ed8e778589b1303a50f20aa14d590c400f5d2d6afa92fa47b5801a7aff516547a4f68de225afa2739600c843eb386ce9589

data/lib/hollerith/argument_decoder.rb

@@ -0,0 +1,60 @@
+class Hollerith::ArgumentDecoder
+  # "result,%%_make_external_request($$_oi,true)"
+  # becomes
+  # ['result', '%%_make_external_request($$_oi,true)']
+  #
+  # harder than it looks :)
+  def self.decode_argument declaration
+    arguments = declaration.match(/\((?>[^)(]+|\g<0>)*\)/)[0][1..-2]
+
+    arguments_array = []
+    each_argument = ''
+    unclosed_parens = 0
+    unclosed_square_brackets = 0
+    unclosed_single_quotes = 0
+    unclosed_double_quotes = 0
+
+    arguments.split('').each do |char|
+      everything_is_closed = (
+        unclosed_parens == 0 &&
+        unclosed_square_brackets == 0 &&
+        unclosed_single_quotes == 0 &&
+        unclosed_double_quotes == 0
+      )
+
+      if everything_is_closed && char == ','
+        arguments_array << each_argument
+        each_argument = ''
+      elsif char == '('
+        unclosed_parens += 1
+        each_argument += char
+      elsif char == ')'
+        unclosed_parens -= 1
+        each_argument+= char
+      elsif char == "["
+        unclosed_square_brackets += 1
+        each_argument += char
+      elsif char == ']'
+        unclosed_square_brackets -= 1
+        each_argument+= char
+      elsif char == "'" && unclosed_single_quotes == 0
+        unclosed_single_quotes += 1
+        each_argument += char
+      elsif char == "'"
+        unclosed_single_quotes -= 1
+        each_argument+= char
+      elsif char == '"' && unclosed_double_quotes == 0
+        unclosed_double_quotes += 1
+        each_argument += char
+      elsif char == '"'
+        unclosed_double_quotes -= 1
+        each_argument+= char
+      else
+        each_argument += char
+      end
+    end
+    arguments_array << each_argument
+
+    arguments_array
+  end
+end

data/lib/hollerith/base_functions.rb

@@ -0,0 +1,231 @@
+class Hollerith::BaseFunctions  
+
+  def valid_functions
+    %w(
+      for_each
+      set
+      if
+      or
+      and
+      negate 
+      count
+      make_external_request
+      custom_function
+      puts
+      concat
+      blank_array
+      array_push
+      array_value
+      eql
+      add
+      subtract
+      multiply
+      divide 
+      split
+    )
+  end
+
+  # Example usage: `%%_for_each($$_planets,%%_custom_function(get_distance_from_sun),each_planet)`
+  # In the `get_distance_from_sun` custom function, `each_planet` will be the variable to reference.
+  # The for each loop will assign a local variable instead of passing as an argument so your function
+  # does not need to define `functions`.
+  #
+  # @param function_array [Array] Expects three arguments, 
+  # the array to iterate over, the callback function and the variable to set each element to.
+  def __for_each function_array
+    object_to_iterate = get_value(function_array.shift)
+
+    if !object_to_iterate.respond_to?(:each)
+      raise ArgumentError.new('Not an iteratable object')
+    end
+
+    object_to_iterate.each do |value|
+      local_context = {
+        function_array[1] => value
+      }
+
+      get_value(function_array[0], local_context)
+    end
+  end
+
+  # Example: `%%_set(my_favourite_planet,'Saturn')`
+  #          Calling $$_my_favourite_planet will now return "Saturn".
+  # @param function_array [Array] Expects two arguments, the variable name and the value.
+  def __set function_array
+    variable_to_set = function_array.shift
+
+    @user_context_change.merge!({
+      variable_to_set => get_value(function_array.shift) 
+    })
+
+    return true 
+  end
+
+  def __make_external_request function_array
+    return true
+  end
+
+  # Example: `%%_set(my_favourite_planet,'Saturn')`
+  #          Calling $$_my_favourite_planet will now return "Saturn".
+  # @param function_array [Array] Expects one to three arguments, the condition, a callback
+  # for when the condition is true, and a callback if the condition is false.
+  def __if function_array
+    if get_value(function_array.shift)
+      if function_array[0]
+        get_value(function_array[0])
+      else
+        return true
+      end
+    else
+      if function_array[1]
+        get_value(function_array[1])
+      else
+        return false 
+      end
+    end
+  end
+
+  def __or function_array
+    function_array.each do |each_condition|
+      if get_value(each_condition)
+        return true
+      end
+    end
+
+    return false 
+  end
+
+  def __and function_array
+    all_true = false
+    function_array.each do |each_condition|
+      if !get_value(each_condition)
+        return false 
+      else 
+        all_true = true
+      end
+    end
+
+    return all_true 
+  end
+
+  def __negate function_array
+    value_to_negate = get_value(function_array.shift)
+
+    if value_to_negate.is_a?(TrueClass)
+      negated_value = false 
+    elsif value_to_negate.is_a?(FalseClass)
+      negated_value = true
+    else 
+      begin
+        negated_value = value_to_negate * -1
+      rescue
+        raise ArgumentError.new("Cannot negate this value #{value_to_negate}")
+      end
+    end
+
+    return negated_value
+  end
+
+  def __custom_function function_array
+    function_name = function_array.shift
+    
+    arguments = @user_defined_functions[function_name]['arguments']
+    functions = @user_defined_functions[function_name]['functions']
+
+    arguments.each do |argument|
+      @user_context[argument] = get_value(function_array.shift)
+    end
+
+    functions.each do |function|
+      get_value(function)
+    end
+  end
+
+  def __puts function_array
+    puts(get_value(function_array.shift))
+  end
+
+  def __concat function_array
+    result = function_array.map do |each_element|
+      get_value(each_element)
+    end.join('')
+
+    result
+  end
+
+  def __blank_array function_array
+    return []
+  end
+
+  def __array_value function_array
+    context_variable_name = get_variable(function_array.shift)
+    if @user_context[context_variable_name].is_a? Array
+      @user_context[context_variable_name][get_value(function_array.shift)]
+    elsif @main_context[context_variable_name].is_a? Array
+      @main_context[context_variable_name][get_value(function_array.shift)]
+    else
+      raise ArgumentError.new("#{context_variable_name} is not an array.")
+    end
+  end
+
+  def __array_push function_array
+    context_variable_name = get_variable(function_array.shift)
+
+    # Only allow modifying the user_context
+    if @user_context[context_variable_name].is_a? Array
+      @user_context_change.merge!({
+        context_variable_name => @user_context[context_variable_name] +
+          [get_value(function_array.shift)]
+      })
+    else
+      raise ArgumentError.new("#{context_variable_name} is not an array.")
+    end
+  end
+
+  def __eql function_array
+    compare_value = get_value(function_array.shift)
+
+    function_array.each do |each_value_to_compare|
+      if get_value(each_value_to_compare) != compare_value 
+        return false
+      end
+    end
+
+    return true
+  end
+
+  def __add function_array
+    get_value(function_array.shift) + get_value(function_array.shift)
+  end
+
+  def __subtract function_array
+    get_value(function_array.shift) - get_value(function_array.shift)
+  end
+
+  def __multiply function_array
+    get_value(function_array.shift) * get_value(function_array.shift)
+  end
+
+  def __divide function_array
+    get_value(function_array.shift) / get_value(function_array.shift)
+  end
+
+  def __split function_array
+    get_value(function_array.shift).split(function_array.shift)
+  end
+
+  def __count function_array
+    get_value(function_array.shift).count
+  end
+
+  private
+
+  def get_variable variable
+    # $$_successful_order_items -> successful_order_items
+    if variable.start_with?('$$_')
+      return variable[3..-1]
+    else
+      raise ArgumentError.new('Must assign to an existing variable')
+    end
+  end
+end

data/lib/hollerith/function_runner.rb

@@ -0,0 +1,62 @@
+require 'hollerith/value_getter'
+require 'hollerith/argument_decoder'
+require 'hollerith/base_functions'
+
+class Hollerith::FunctionRunner < Hollerith::BaseFunctions
+  attr_reader :user_context_change
+  
+  def initialize declaration, main_context, user_context, user_defined_functions
+    @declaration = declaration
+    @main_context = main_context
+    @user_context = user_context
+    @user_context_change = {}
+    @user_defined_functions = user_defined_functions
+  end
+
+  def evaluate
+    if @declaration.start_with?('%%_')
+      function = @declaration[3..-1].split(/,|\(|\)/)
+
+      # This will create a function array
+      # '%%_set(result,%%_make_external_request($$_oi))'
+      # becomes
+      # ["set", "result", "%%_make_external_request", "$$_oi"]
+      if valid_functions.include?(function[0])
+        arguments_array = get_arguments_from_declaration
+
+        if self.respond_to?("__#{function[0]}", arguments_array)
+          send("__#{function[0]}", arguments_array)
+        else
+          raise ArgumentError.new("#{function[0]} is listed as a valid function but not implemented.")
+        end
+      else
+        raise ArgumentError.new("Undefined function #{function[0]}.")
+      end
+    else
+      raise ArgumentError.new("Exepected function, received #{@declaration}.")
+    end
+  end
+
+  private
+
+  def get_value value_to_get, local_context = {}
+    getter = Hollerith::ValueGetter.new(
+      @main_context,
+      @user_context,
+      @user_defined_functions,
+      @user_context_change,
+      local_context
+    )
+
+    return_value = getter.get(value_to_get)
+
+    @user_context_change.merge!(getter.user_context_change || {}) 
+
+    return_value
+  end
+
+  def get_arguments_from_declaration
+    Hollerith::ArgumentDecoder.decode_argument(@declaration)
+  end
+
+end

data/lib/hollerith/value_getter.rb

@@ -0,0 +1,79 @@
+require "hollerith/function_runner"
+
+class Hollerith::ValueGetter
+
+  attr_reader :user_context_change
+
+  def initialize user_context, main_context, user_defined_functions, user_context_change, local_context = {} 
+    # local_context is only used for the getting of this value
+    # and does not get bubbled up to other function calls,
+    # helpful for each loops in functions.
+    @main_context = main_context  
+    @user_context = user_context.merge(local_context)
+    @user_defined_functions = user_defined_functions  
+    @user_context_change = user_context_change  
+  end
+
+  def get value_to_get
+    if !value_to_get.is_a? String
+      return value_to_get
+    elsif value_to_get.downcase == 'true'
+      return true
+    elsif value_to_get.downcase == 'false'
+      return false
+    elsif value_to_get.to_i.to_s == value_to_get 
+      value_to_get.to_i
+    elsif value_to_get.start_with?('$$_')
+      hash_key = value_to_get[3..-1].strip
+      read_hash_value(hash_key)
+    elsif value_to_get.start_with?('%%_')
+      runner = Hollerith::FunctionRunner.new(
+        value_to_get,
+        @main_context,
+        @user_context.merge(@user_context_change || {}),
+        @user_defined_functions
+      )
+
+      result = runner.evaluate
+
+      @user_context_change.deep_merge!(runner.user_context_change || {}) 
+
+      get(result)
+    elsif value_to_get.is_a?(String) && (value_to_get.start_with?("'") || value_to_get.start_with?('"')) && (value_to_get.end_with?("'") || value_to_get.end_with?('"'))
+      value_to_get[1..-2]
+    else
+      value_to_get
+    end
+  end
+
+  def read_hash_value hash_key
+    split_hash_key = hash_key.split('.')
+    base_hash_key = split_hash_key.shift
+
+    if @user_context.has_key?(base_hash_key)
+      hash_key_value = @user_context[base_hash_key]
+    else
+      hash_key_value = @main_context[base_hash_key]
+    end
+
+    split_hash_key.each do |each_hash_key|
+      if hash_key_value.is_a?(Hash) 
+        hash_key_value = hash_key_value[each_hash_key]
+      else
+        if hash_key_value.respond_to?(:attributes) && hash_key_value.attributes.include?(each_hash_key)
+          hash_key_value = hash_key_value.send(each_hash_key)
+        elsif hash_key_value.respond_to?(:instance_variables) && hash_key_value.instance_variables.map(&:to_s).include?("@#{each_hash_key}")
+          hash_key_value = hash_key_value.send(each_hash_key)
+        else
+          hash_key_value = nil
+        end
+      end
+    end
+
+    # TODO: Add dot notation handling here.
+    #       - Read all rails attributes, hash values or instance variables.
+    # FIXME: Variable getting needs to be DRYed up.
+
+    return hash_key_value
+  end
+end

data/lib/hollerith.rb

@@ -0,0 +1,127 @@
+class Hollerith 
+
+  HOOKS = %w(
+    on_place_order
+    on_update_order
+  )
+
+  def initialize configuration, main_context = {}
+    @configuration = configuration 
+    @main_context = main_context
+    @user_context = @configuration['configuration'] || {}
+    @user_defined_functions = @configuration['custom_functions'] 
+  end
+
+  def trigger_hook hook
+    @configuration[hook].each do |each_hook_implementation|
+      if hook_should_be_run(each_hook_implementation)
+        execute_hook_implementation(each_hook_implementation)
+      end
+    end
+  end
+
+  def hook_should_be_run(hook_implementation)
+    if hook_implementation.has_key?('run_if')
+      evaluate_conditional(hook_implementation['run_if'])      
+    elsif hook_implementation.has_key?('run_unless')
+      !evaluate_conditional(hook_implementation['run_unless'])      
+    else
+      true
+    end
+  end
+
+  def execute_hook_implementation definition
+    if definition['before'] && definition['before']['functions']
+      evaluate_functions(definition['before']['functions'])
+    end
+
+    case definition['method']
+    when 'none'
+      evaluate_functions(definition['functions'])
+    when 'conditional'
+      # TODO
+      raise "Not implemented!" 
+    when 'for_each'
+      before_iteration_functions = definition['for_each']['before_iteration']
+      each_iteration_rules = definition['for_each']['each_iteration']
+      break_when = definition['for_each']['break_iteration_if']
+      next_when = definition['for_each']['next_if']
+
+      evaluate_functions(before_iteration_functions)
+
+      get_iterator(definition['loop']) do
+        next if evaluate_conditional(next_when)
+
+        evaluate_functions(each_iteration_rules)        
+        break if evaluate_conditional(break_when)
+      end
+    end
+
+    if definition['finally'] && definition['finally']['functions']
+      evaluate_functions(definition['finally']['functions'])
+    end
+  end
+
+  def get_iterator iterator_definition
+    # `$$_schools as each_school`
+    collection_variable, each_value_variable = iterator_definition.split(' as ')
+
+    get_variable_from_context(collection_variable).each do |each_iteration|
+      @user_context[each_value_variable] = each_iteration
+      yield
+    end
+  end
+
+  def get_variable_from_context variable
+    if variable.start_with?('$$_')
+      value_to_return = @main_context[variable[3..-1].strip]   
+
+      if value_to_return
+        return value_to_return
+      else
+        raise ArgumentError.new("Variable not found #{value_to_return} in this context")
+      end
+    else
+      raise ArgumentError.new("Invalid variable definition #{variable}")
+    end
+  end
+
+  def evaluate_functions functions
+    if functions.compact.any?
+      functions.compact.each do |function|
+        evaluate_function(function)
+      end
+    end
+  end
+
+  def evaluate_conditional conditional_statement
+    return false unless conditional_statement
+
+    evaluate_function(conditional_statement)
+  end
+
+  def evaluate_function function_definition
+    return unless function_definition
+
+    runner = Hollerith::FunctionRunner.new(
+      function_definition,
+      @main_context,
+      @user_context,
+      @user_defined_functions
+    )
+
+    results = runner.evaluate
+
+    if runner.user_context_change
+      @user_context.deep_merge!(runner.user_context_change)
+    end
+    
+    return results
+  end
+
+end
+
+require 'hollerith/function_runner'
+require 'hollerith/value_getter'
+require 'hollerith/argument_decoder'
+require 'hollerith/base_functions'

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: hollerith
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Noah Kochanowicz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-09-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+description: Trigger code through a series of hooks and run code in loops and through
+  conditions.
+email: me@noahkoch.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hollerith.rb
+- lib/hollerith/argument_decoder.rb
+- lib/hollerith/base_functions.rb
+- lib/hollerith/function_runner.rb
+- lib/hollerith/value_getter.rb
+homepage: https://rubygems.org/gems/hollerith
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Create and run functions in JSON.
+test_files: []