chutzen 0.8.0

data/lib/chutzen/dictionary.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Chutzen
+  # Holds a hash and allows retrieval of data with a simple lookup syntax.
+  class Dictionary
+    # Creates a new Dictionary with an option initial hash of data.
+    def initialize(data = {})
+      @data = data
+      @mutex = Mutex.new
+    end
+
+    def to_hash
+      @data
+    end
+
+    # Get a value using a dot expression (eg. 'export.filename'). Does not work with deep search
+    # indentifiers.
+    def [](key)
+      dig(*Chutzen::Expression.split(key))
+    end
+
+    def []=(key, value)
+      @mutex.synchronize do
+        @data[key.to_s] = value
+      end
+    end
+
+    # Returns true when a value was set for the path, so that means it also returns true when the
+    # value is nil.
+    def exist?(*path)
+      data = path.length > 1 ? @data.dig(*path[0..-2]) : @data
+      data&.key?(path.last)
+    end
+
+    # See Hash#dig.
+    def dig(*path)
+      @data.dig(*path)
+    end
+
+    # Performs a depth first search for the first item in the path. After that it works just like
+    # dig on the rest of the path.
+    def dig_deep(*path)
+      found_path = self.class.search(@data, path[0])
+      found_path ? @data.dig(*(found_path.reverse + path[1..])) : nil
+    end
+
+    # Add or replace a value with a path.
+    def bury!(path, value)
+      @mutex.synchronize do
+        self.class.bury(@data, path, value)
+      end
+    end
+
+    # Merge a hash into the dictionary.
+    def merge!(data)
+      @mutex.synchronize do
+        @data.merge!(data)
+      end
+    end
+
+    # Merge a hash into the dictionary without replacing existing values.
+    def deep_merge!(data)
+      @mutex.synchronize do
+        DeepMerge.new(@data, data).perform
+      end
+    end
+
+    # Searches the data depth-first for a key and returns the path to that
+    # key for the first match.
+    def self.search(data, key)
+      case data
+      when Hash
+        search_hash(data, key)
+      when Array
+        search_array(data, key)
+      end
+    end
+
+    def self.search_hash(data, key)
+      if data.key?(key)
+        [key]
+      else
+        data.each do |name, value|
+          path = search(value, key)
+          return (path << name) if path
+        end
+        nil
+      end
+    end
+
+    def self.search_array(data, key)
+      data.each.with_index do |item, index|
+        path = search(item, key)
+        return (path << index) if path
+      end
+      nil
+    end
+
+    def self.bury(data, path, value)
+      key, *rest = path
+      if rest.empty?
+        data[key] = value
+      elsif data.key?(key)
+        bury(data[key], rest, value)
+      else
+        data[key] = build(rest, value)
+      end
+    end
+
+    def self.build(path, value)
+      reference, *rest = path
+      if reference.is_a?(Numeric) && reference < 256
+        build_array(reference, rest, value)
+      else
+        build_hash(reference, rest, value)
+      end
+    end
+
+    def self.build_array(index, rest, value)
+      if rest.empty?
+        [].insert(index, value)
+      else
+        [].insert(index, build(rest, value))
+      end
+    end
+
+    def self.build_hash(key, rest, value)
+      if rest.empty?
+        { key => value }
+      else
+        { key => build(rest, value) }
+      end
+    end
+  end
+end

data/lib/chutzen/expression/lookup_error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Chutzen
+  class Expression
+    # Raised when Chutzen can't find a value in the job dictionary.
+    class LookupError < Chutzen::StandardError
+      attr_reader :expression, :dictionary
+
+      def initialize(message, expression: nil, dictionary: nil)
+        super(message)
+        @expression = expression
+        @dictionary = dictionary
+      end
+
+      def as_json
+        { 'error' => details }
+      end
+
+      private
+
+      def details
+        {
+          'message' => message,
+          'expression' => @expression&.to_s,
+          'dictionary' => @dictionary&.to_hash
+        }.compact
+      end
+    end
+  end
+end

data/lib/chutzen/expression/syntax_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chutzen
+  class Expression
+    # Raised when something went wrong while parsing a Chutzen expression.
+    class SyntaxError < Chutzen::StandardError
+      attr_reader :expression
+
+      def initialize(message, expression: nil)
+        super(message)
+        @expression = expression
+      end
+
+      def as_json
+        { 'error' => details }
+      end
+
+      private
+
+      def details
+        {
+          'message' => message,
+          'expression' => @expression&.to_s
+        }.compact
+      end
+    end
+  end
+end

data/lib/chutzen/expression.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'parslet'
+
+module Chutzen
+  # Transforms a Chutzen expression by transforming it and replacing any query expressions with
+  # their values.
+  class Expression
+    autoload :SyntaxError, 'chutzen/expression/syntax_error'
+    autoload :LookupError, 'chutzen/expression/lookup_error'
+
+    INTEGER_RE = /\A\d+\z/.freeze
+    OPERATIONS = {
+      '=' => ->(left, right) { left == right },
+      '&' => ->(left, right) { left & right },
+      '|' => ->(left, right) { left | right },
+      '<' => ->(left, right) { left & right ? left < right : nil },
+      '>' => ->(left, right) { left & right ? left > right : nil }
+    }.freeze
+
+    Transformer = Parslet::Transform.new do
+      rule(undefined: simple(:value)) { nil }
+      rule(boolean: simple(:value)) { value.to_s == 'true' }
+      rule(integer: simple(:value)) { value.to_i }
+      rule(float: simple(:value)) { value.to_f }
+      rule(string: simple(:value)) { value.to_s }
+
+      rule(identifier: simple(:name)) do
+        path = *Chutzen::Expression.split(name)
+        if dictionary.exist?(*path)
+          dictionary.dig(*path)
+        else
+          raise(
+            LookupError.new(
+              "No value for #{name}", expression: name.to_s, dictionary: dictionary
+            )
+          )
+        end
+      end
+
+      rule(search_identifier: simple(:name)) do
+        dictionary.dig_deep(*Chutzen::Expression.split(name))
+      end
+
+      rule(
+        operation: {
+          left: simple(:left), operator: simple(:operator), right: simple(:right)
+        }
+      ) do
+        OPERATIONS[operator.to_s].call(left, right)
+      end
+    end
+
+    def initialize(expression, dictionary)
+      @expression = Chutzen::ExpressionParser.new.parse(expression)
+      @dictionary = dictionary
+    rescue Parslet::ParseFailed => e
+      raise Chutzen::Expression::SyntaxError.new(
+        e.parse_failure_cause.ascii_tree,
+        expression: expression
+      )
+    end
+
+    def result
+      Transformer.apply(@expression, dictionary: @dictionary)
+    end
+
+    def self.split(key)
+      key.to_s.split('.').map do |segment|
+        INTEGER_RE.match(segment) ? segment.to_i : segment
+      end
+    end
+  end
+end

data/lib/chutzen/expression_parser.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'parslet'
+
+module Chutzen
+  # Parses an expression in the Chutzen language.
+  class ExpressionParser < Parslet::Parser
+    rule(:spaces) { match('\s').repeat(1) }
+    rule(:spaces?) { spaces.maybe }
+
+    rule(:numeric) { match('[0-9]').repeat(1) }
+    rule(:integer) { numeric.as(:integer) }
+    rule(:float) { ((numeric >> str('.')).repeat(1) >> numeric).as(:float) }
+
+    rule(:undefined) { str('undefined').as(:undefined) }
+    rule(:boolean) { (str('true') | str('false')).as(:boolean) }
+
+    rule(:quote) { str("'") }
+    rule(:string) { match("[^']").repeat(1) }
+    rule(:quoted_string) { quote >> string.as(:string) >> quote }
+
+    rule(:literal) { undefined | float | integer | boolean | quoted_string }
+
+    rule(:search) { str('//') }
+    rule(:key) { match['\w'].repeat(1) }
+    rule(:atom) { key | integer }
+    rule(:absolute_identifier) { atom >> (str('.') >> atom).repeat }
+    rule(:search_identifier) { search >> absolute_identifier.as(:search_identifier) }
+    rule(:identifier) do
+      search_identifier | absolute_identifier.as(:identifier)
+    end
+
+    rule(:simple_expression) { literal | identifier }
+
+    rule(:operator) { match('[&|=<>]') }
+    rule(:operation) do
+      simple_expression.as(:left) >> spaces? >>
+        operator.as(:operator) >> spaces? >>
+        simple_expression.as(:right)
+    end
+
+    rule(:expression) do
+      operation.as(:operation) | simple_expression
+    end
+    root(:expression)
+  end
+end

data/lib/chutzen/job.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'etc'
+
+module Chutzen
+  # Holds a description for a job and executes it.
+  class Job
+    include Enumerable
+
+    def initialize(description)
+      @notify = nil
+      @result = {}
+      description.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+      @uuid = SecureRandom.uuid
+      @work_path = File.join(ENV['HOME'], 'chutzen', @uuid)
+      @dictionary = Dictionary.new(properties)
+    end
+
+    def properties
+      {
+        'uuid' => @uuid,
+        'work_path' => @work_path,
+        'uname' => Etc.uname.transform_keys(&:to_s),
+        'nprocs' => Etc.nprocessors,
+        'chutzen_version' => Chutzen::VERSION
+      }
+    end
+
+    # Yields Command instances for each command in the description.
+    def each
+      @commands.each do |description|
+        yield Command.new(
+          description,
+          dictionary: @dictionary,
+          work_path: @work_path
+        )
+      end
+    end
+
+    # Perform all commands in the job.
+    def perform
+      FileUtils.mkdir_p(@work_path)
+      map do |command|
+        perform_notification(command.perform)
+        command
+      end
+    rescue Chutzen::StandardError => e
+      warn("Job failed: #{e}")
+      perform_exception_notification(e)
+    ensure
+      FileUtils.rm_rf(@work_path)
+    end
+
+    private
+
+    def global_result
+      @result || {}
+    end
+
+    # Pushes a notification into the Sidekiq queue for each command that
+    # produces a result.
+    def perform_notification(command)
+      return unless @notify
+      return unless command
+
+      result = command.result
+      return unless result
+
+      Notification.perform_async(@notify, global_result.merge(result))
+    end
+
+    def perform_exception_notification(error)
+      return unless @notify
+
+      Notification.perform_async(@notify, global_result.merge(error.as_json))
+    end
+  end
+end

data/lib/chutzen/notification.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chutzen
+  # Helper class to push a Sidekiq job on the specified callback queue with the
+  # specified class and arguments.
+  class Notification
+    # Returns defaults for a Sidekiq job. See Sidekiq documentation for value
+    # params. We suggest using 'queue', 'class', and 'args'.
+    def self.defaults
+      { 'queue' => 'default' }
+    end
+
+    # Schedules a notification by creating a Sidekiq job using the job
+    # description and a Ruby object as a payload.
+    #
+    #   Notification.perform_async(
+    #     { 'class' => 'MyApplication::Result' },
+    #     { 'filename' => 'ok.txt', 'name' => 'ok' }
+    #   )
+    #
+    # The payload is serialized as JSON to reduce potential interoperability
+    # problems and to make it easier to write forward and backward support
+    # for the worker classes.
+    def self.perform_async(job, payload)
+      Sidekiq::Client.push(
+        defaults.merge(
+          job.merge('args' => [JSON.dump(payload)])
+        )
+      )
+    end
+  end
+end

data/lib/chutzen/runtime_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Chutzen
+  # Raised when something went wrong while evaluating a Chutzen expression.
+  class RuntimeError < Chutzen::StandardError
+    def initialize(message, **details)
+      super(message)
+      @details = details
+    end
+
+    def as_json
+      { 'error' => details }
+    end
+
+    private
+
+    def details
+      { 'message' => message }.merge(@details.transform_keys(&:to_s))
+    end
+  end
+end

data/lib/chutzen/shell.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Chutzen
+  # Implements utilities to safely run commands on the shell.
+  class Shell
+    def self.join(execute)
+      case execute
+      when Hash
+        join_hash(execute)
+      when Array
+        join_array(execute)
+      else
+        execute
+      end
+    end
+
+    def self.join_hash(execute)
+      execute.map do |name, value|
+        value ? "#{name} #{value}" : name
+      end.join(' ')
+    end
+
+    def self.join_array(execute)
+      execute.map { |part| join(part) }.join(' ')
+    end
+  end
+end

data/lib/chutzen/signal.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+require 'sidekiq/cli'
+
+module Chutzen
+  # Sidekiq worker to accept operational signals and commands through the queue.
+  class Signal
+    include Sidekiq::Worker
+
+    sidekiq_options queue: Chutzen.sidekiq_queue, retry: false
+
+    # Send a signal to the Chutzen process.
+    #
+    # == Signal names
+    #
+    # * +stop+ stops the current process from accepting new jobs
+    #
+    # @param signal [string] the signal you want to send
+    # @param expires_at [integer] ignore signal after this time (in seconds
+    #                             since 1970)
+    def perform(signal, expires_at = nil)
+      if fresh?(expires_at)
+        perform_signal(signal)
+      else
+        Sidekiq.logger.info("Ignoring signal `#{signal}' because it expired at #{expires_at}.")
+      end
+    end
+
+    private
+
+    def fresh?(expires_at)
+      if expires_at
+        Time.at(expires_at) > Time.now
+      else
+        true
+      end
+    end
+
+    def perform_signal(signal)
+      case signal
+      when 'stop'
+        Sidekiq::CLI.instance.handle_signal('TSTP')
+      else
+        raise(ArgumentError, "Unknown signal `#{signal}'")
+      end
+    end
+  end
+end

data/lib/chutzen/standard_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Chutzen
+  # Base class for all exceptions in Chutzen.
+  class StandardError < ::StandardError
+    def as_json
+      { 'error' => { 'message' => message } }
+    end
+  end
+end

data/lib/chutzen/template/syntax_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Chutzen
+  class Template
+    # Raised when something went wrong while parsing a Chutzen template.
+    class SyntaxError < Chutzen::StandardError
+      attr_reader :template
+
+      def initialize(message, template: nil)
+        super(message)
+        @template = template
+      end
+
+      def as_json
+        { 'error' => details }
+      end
+
+      private
+
+      def details
+        {
+          'message' => message,
+          'template' => @template&.to_s
+        }.compact
+      end
+    end
+  end
+end

data/lib/chutzen/template.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'parslet'
+
+module Chutzen
+  # Replaces Chutzen queries and variable templates in a text template using a dictionary of
+  # values.
+  class Template
+    autoload :SyntaxError, 'chutzen/template/syntax_error'
+
+    Transformer = Parslet::Transform.new do
+      rule(expression: simple(:expression)) do
+        Chutzen::Expression.new(expression.to_s, dictionary).result
+      end
+      rule(global: simple(:name)) { dictionary[name.to_s] }
+      rule(string: simple(:value)) { value.to_s }
+    end
+
+    def initialize(template, dictionary)
+      @template = Chutzen::TemplateParser.new.parse(template)
+      @dictionary = dictionary
+    rescue Parslet::ParseFailed => e
+      raise Chutzen::Template::SyntaxError.new(
+        e.parse_failure_cause.ascii_tree,
+        template: template
+      )
+    end
+
+    def result
+      result = Transformer.apply(@template, dictionary: @dictionary)
+      case result
+      when Array
+        result.join
+      else
+        result
+      end
+    end
+  end
+end

data/lib/chutzen/template_parser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'parslet'
+
+module Chutzen
+  # Parses a template for variable expressions.
+  class TemplateParser < Parslet::Parser
+    rule(:string) { match('[^$]').repeat(1).as(:string) }
+
+    rule(:variable) { str('${') >> match('\\\}|[^}]').repeat(1).as(:expression) >> str('}') }
+    rule(:global) { str('@') >> match('\w').repeat(1).as(:global) }
+    rule(:part) { variable | string }
+
+    rule(:template) { str('') | global | part.repeat(1) }
+    root(:template)
+  end
+end

data/lib/chutzen/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Chutzen
+  VERSION = '0.8.0'
+end