balmora 0.0.1

data/lib/balmora/command/stop.rb

@@ -0,0 +1,17 @@
+class Balmora::Command::Stop < Balmora::Command
+
+  class Error < StandardError; end
+
+  def options()
+    return super().concat([:status])
+  end
+
+  def verify()
+    return true
+  end
+
+  def run()
+    raise Balmora::Stop.new(nil, @status)
+  end
+
+end

data/lib/balmora/command/yaourt.rb

@@ -0,0 +1,8 @@
+class Balmora::Command::Yaourt < Balmora::Command::Pacman
+
+  def initialize(state, command)
+    super(state, command)
+    @bin = ['yaourt']
+  end
+
+end

data/lib/balmora/config.rb

@@ -0,0 +1,190 @@
+require 'json'
+
+class Balmora::Config
+
+  class Error < StandardError; end
+
+  attr_accessor :file, :dir, :require, :variables
+  attr_reader :old, :config
+
+  def self.factory(state)
+    return self.create(state.options[:config], state.variables)
+  end
+
+  def self.create(config = nil, variables = nil)
+    if config.nil?()
+      config = File.join(Dir.home(), '.config/balmora/balmora.conf')
+    end
+
+    if !File.exist?(config)
+      config = File.join('/etc/balmora/balmora.conf')
+    end
+
+    if !File.exist?(config)
+      raise Error.new('Config not found in ~/.config/balmora/balmora.conf ' +
+        'and /etc/balmora/balmora.conf; you should create config to ' +
+        'continue or use --config switch')
+    end
+
+    return self.new(config || '~/.config/balmora/balmora.conf', variables)
+  end
+
+  def initialize(path, variables = nil)
+    @file = File
+    @dir = Dir
+
+    @variables = variables
+    @path = path
+    @require = Object.method(:require)
+
+    @config = nil
+  end
+
+  def get(key = [], options = {})
+    if !key.instance_of?(::Array)
+      key = [key]
+    end
+
+    result =
+      key.
+      inject(@config) { |current, part|
+        begin
+          current = current.fetch(part)
+        rescue KeyError
+          if options[:default]
+            return options[:default]
+          end
+
+          raise "Config value #{key.inspect()} should be defined in " +
+            "#{@path.inspect()}"
+        end
+
+        next current
+      }
+
+    result = _deep_clone(result)
+    if options[:variables] != false
+      result = @variables.inject(result, false)
+    end
+
+    return result
+  end
+
+  def load()
+    @old = _deep_clone(@config)
+
+    Dir.chdir(File.dirname(@path)) {
+      @config = _load(@path)
+    }
+
+    @config[:config_dir] = File.dirname(@path)
+    @config[:config_path] = @path
+
+    get(:require, default: [], variables: false).each() { |file|
+      @require.call(file)
+    }
+  end
+
+  def _load(path)
+    contents = @file.read(@file.expand_path(path))
+    value = JSON.parse(contents, {symbolize_names: true})
+    value = _process(value)
+    return value
+  rescue => error
+    raise Error.new("Failed to read config file #{path}: #{error.to_s()}")
+  end
+
+  def _process(value)
+    result =
+      if value.instance_of?(::Array)
+        _process_array(value)
+      elsif value.instance_of?(::Hash)
+        _process_hash(value)
+      else
+        value
+      end
+
+    return result
+  end
+
+  def _process_array(value)
+    result = []
+    value.each() { |item|
+      if item.instance_of?(::Hash) && item.keys() == [:'extend-file']
+        files = item[:'extend-file']
+        if !files.instance_of?(::Array)
+          files = [files]
+        end
+
+        files.each() { |path|
+          _glob(path).each() { |file|
+            result.concat(_load(file))
+          }
+        }
+      else
+        result.push(_process(item))
+      end
+    }
+
+    return result
+  end
+
+  def _process_hash(value)
+    result = {}
+    value.each() { |key, item|
+      if key == :'include-file'
+        files = item
+        if !files.instance_of?(::Array)
+          files = [files]
+        end
+
+        files.each() { |path|
+          _glob(path).each() { |file|
+            result.merge!(_load(file))
+          }
+        }
+      else
+        result[key] = _process(item)
+      end
+    }
+
+    return result
+  end
+
+  def _glob(file)
+    if !file.include?('*')
+      return [file]
+    end
+
+    return @dir.glob(file)
+  end
+
+  def _deep_clone(value)
+    if value.instance_of?(::Array)
+      value = value.collect() { |item|
+        _deep_clone(item)
+      }
+    elsif value.instance_of?(::Hash)
+      value = Hash[
+        value.collect() { |key, item|
+          [_deep_clone(key), _deep_clone(item)]
+        }
+      ]
+    else
+      is_clonable = (
+        !value.is_a?(::Numeric) &&
+        !value.is_a?(::TrueClass) &&
+        !value.is_a?(::FalseClass) &&
+        !value.is_a?(::NilClass) &&
+        !value.is_a?(::Symbol)
+      )
+
+      if is_clonable
+        value = value.clone()
+      end
+    end
+
+    return value
+  end
+
+end

data/lib/balmora/context.rb

@@ -0,0 +1,98 @@
+class Balmora::Context < Balmora::Command
+
+  def initialize(state, context)
+    @state = state
+
+    @logger = state.logger
+    @shell = state.shell
+    @config = state.config
+    @variables = state.variables
+    @balmora = state.balmora
+
+    @context = context
+  end
+
+  def init()
+    if (@context.keys() - [:context] - options()).length != 0
+      raise Error.new("Unknown options #{(@context.keys() - [:context] -
+        options()).inspect()}")
+    end
+
+    options().each() { |key|
+      if self.instance_variable_defined?(:"@#{key}")
+        raise Error.new("Can not use #{key} as option")
+      end
+
+      option = @context.fetch(key, nil)
+      self.instance_variable_set(:"@#{key}", option)
+    }
+
+    verify()
+  end
+
+  def options()
+    return [:operator, :value]
+  end
+
+  def verify()
+    if @operator.nil?()
+      raise Error.new('"operator" should be defined')
+    end
+
+    if @value.nil?()
+      raise Error.new('"value" should be defined')
+    end
+  end
+
+  def execute()
+    result = run()
+
+    operator = @operator
+
+    is_not = false
+    if operator.start_with?('not-')
+      is_not = true
+      operator = operator[4..-1]
+    end
+
+    case operator
+      when 'match'
+        return _not(is_not, result.match(@value) != nil)
+      when 'equal'
+        return _not(is_not, result == @value)
+      when 'greater'
+        return _not(is_not, result > @value)
+      when 'greater-or-equal'
+        return _not(is_not, result >= @value)
+      when 'lesser'
+        return _not(is_not, result < @value)
+      when 'lesser-or-equal'
+        return _not(is_not, result <= @value)
+    end
+
+    raise Error.new("Unknown operator #{operator}")
+  rescue => error
+    @logger.error("#{error.inspect()}; failed to run " +
+      "context: #{@context.inspect()}")
+
+    raise error
+  end
+
+  def _not(is_not, result)
+    if is_not
+      return !result
+    end
+
+    return result
+  end
+
+  def run()
+    raise Error.new("run should be implemented in subclass")
+  end
+
+  def option(option)
+    return @variables.inject(self.instance_variable_get(:"@#{option}"))
+  end
+
+
+end

data/lib/balmora/context/config_changed.rb

@@ -0,0 +1,11 @@
+class Balmora::Context::ConfigChanged < Balmora::Context
+
+  def run()
+    if @config.old.nil?() || @config.config.nil?()
+      return @config.config == @config.old
+    end
+
+    return JSON.generate(@config.config) != JSON.generate(@config.old)
+  end
+
+end

data/lib/balmora/context/exec.rb

@@ -0,0 +1,26 @@
+class Balmora::Context::Exec < Balmora::Context
+
+  def options()
+    return super().concat([:exec])
+  end
+
+  def verify()
+    if !@exec
+      raise Error.new('"exec" should be defined')
+    end
+
+    super()
+  end
+
+  def run()
+    return @shell.run!(_exec(), verbose: false).rstrip()
+  end
+
+  def _exec()
+    exec = option(:exec)
+    if exec.instance_of?(::String)
+      exec = [@shell.expression(exec)]
+    end
+  end
+
+end

data/lib/balmora/context/exec_result.rb

@@ -0,0 +1,7 @@
+class Balmora::Context::ExecResult < Balmora::Context::Exec
+
+  def run()
+    return @shell.run(_exec(), verbose: false)[0]
+  end
+
+end

data/lib/balmora/contexts.rb

@@ -0,0 +1,76 @@
+class Balmora::Contexts
+
+  def self.factory(state)
+    return self.new(state.logger, state.extension, state.variables, state)
+  end
+
+  def initialize(logger, extension, variables, state)
+    @state = state
+    @logger = logger
+    @extension = extension
+    @variables = variables
+  end
+
+  def check(context)
+    if context.nil?()
+      return true
+    end
+
+    if context.instance_of?(::Array)
+      return _check_array(context)
+    end
+
+    if context.instance_of?(::String)
+      context = {
+        context: 'exec-result',
+        exec: context,
+        operator: 'equal',
+        value: 0,
+      }
+    end
+
+
+    context_class = @extension.get(Balmora::Context, context[:context])
+    context_instance = context_class.new(@state, context)
+    context_instance.init()
+
+    if !(context_class < Balmora::Context)
+      raise Error.new("Context #{context_class} should be subclass of context")
+    end
+
+    context_instance.verify()
+    result = context_instance.execute()
+    return result
+  end
+
+  def _check_array(contexts)
+    operator = :and
+    result = true
+    contexts.each() { |context|
+      if context == 'or'
+        operator = :or
+        next
+      end
+
+      if operator == :or
+        result = result || check(context)
+        operator = :and
+      else
+        if !result
+          next
+        end
+
+        result = result && check(context)
+      end
+    }
+
+    return result
+  end
+
+end
+
+# [
+#   {"context": "test -e folder/file1; echo $?", "operator": "equal", "value": "0"},
+#   "or",
+#   {"context": "test -e folder/file2; echo $?", "operator": "equal", "value": "0"},
+# ]

data/lib/balmora/extension.rb

@@ -0,0 +1,58 @@
+class Balmora::Extension
+
+  class Error < StandardError; end
+
+  attr_accessor :command_constant, :extension_constant
+
+  def self.factory(state)
+    return self.new(state)
+  end
+
+  def initialize(state)
+    @command_constant = ::Balmora::Command
+    @extension_constant = ::Balmora::Extension
+    @state = state
+  end
+
+  def get(namespace, extension)
+    class_name =
+      extension.
+      to_s().
+      gsub(/(-|^)(\w)/) { |char | (char[1] || char[0]).upcase() }.
+      to_sym()
+
+    if !namespace.const_defined?(class_name, false)
+      raise Error.new("Extension #{class_name.inspect()} not found in " +
+        "namespace " + namespace.inspect())
+    end
+
+    return namespace.const_get(class_name, false)
+  end
+
+  def create_command(state, command)
+    if command.instance_of?(::String)
+      command = {command: 'exec', exec: command}
+    end
+
+    if command[:command].nil?()
+      raise Error.new("\"command\" should be defined in command " +
+        "#{command.inspect()}")
+    end
+
+    command_name = @state.variables.inject(command[:command])
+    command_class = get(@command_constant, command_name)
+    if !(command_class < @command_constant)
+      raise Error.new("Command should be instance of #{@command_constant}")
+    end
+
+    command_instance = command_class.new(state, command)
+
+    (command[:extensions] || []).each() { |extension|
+      extension_class = get(@extension_constant, extension)
+      command_instance.extend(extension_class)
+    }
+
+    return command_instance
+  end
+
+end