gene_system 0.3.2

data/lib/gene_system/manifest.rb

@@ -0,0 +1,127 @@
+require 'jsonnet'
+require 'hashie'
+
+module GeneSystem
+  # Manifest is an in memory representation of a manifest file
+  class Manifest
+    DEFAULT_QUERY = ->(_step) { return true }
+
+    class <<self
+      ##
+      # Creates a [GeneSystem::Manifest] from a manifest json so long as the
+      # manifest is compatible with this version of GeneSystem.
+      #
+      # @param [String] file_path
+      #
+      def new_from_file(file_path)
+        manifest = Jsonnet.evaluate(
+          File.read(file_path)
+        )
+
+        if incompatible?(manifest)
+          raise 'provided manifest is invalid or incompatible with '\
+          'this version of gene_system'
+        end
+
+        new(
+          file_path,
+          manifest
+        )
+      end
+
+      ##
+      # Incompatible returns true if the current manifest is not compatible
+      # with this version of GeneSystem.
+      #
+      # A manifest is not compatible if it was created with a version greater
+      # than this the installed version.
+      #
+      # @param [Hash] manifest
+      #
+      # @return [Boolean]
+      #
+      def incompatible?(manifest)
+        manifest_version = manifest['metadata']['gene_system']['version']
+        manifest_version > GeneSystem::VERSION
+      rescue NoMethodError
+        true
+      end
+    end
+
+    # list of supported platforms
+    SUPPORTED_PLATFORMS = %w[macos debian].freeze
+
+    def initialize(path, data)
+      @path = path
+      @data = Hashie::Mash.new(data)
+      @steps = GeneSystem::Step.load_steps(@data.steps)
+    end
+
+    ##
+    # Manifest name getter
+    #
+    # @return [String]
+    #
+    def name
+      @data.name
+    end
+
+    ##
+    # Manifest version getter
+    #
+    # @return [String]
+    #
+    def version
+      @data.version
+    end
+
+    ##
+    # Manifest metadata getter
+    #
+    # @return[String]
+    #
+    def metadata
+      @data.metadata
+    end
+
+    ##
+    # Platform metadata getter
+    #
+    # Prints a warning when the platform is not recognized
+    #
+    # @return[String]
+    #
+    def platform
+      platform = @data.platform
+
+      unless SUPPORTED_PLATFORMS.include?(platform)
+        CLI.print_warning("WARN: unrecognized platform: #{@data.platform}")
+      end
+
+      platform
+    end
+
+    ##
+    # Steps executes a query function in a select call against each step to
+    # return a list of steps relevant to an operation.
+    #
+    # The given query function should evaluate to true when the desired step
+    # should be in the return set.
+    #
+    # By default a all steps will be returned.
+    #
+    # @example
+    # query = ->(step) { step.tags.include?("foo") }
+    # manifest.steps(query)
+    #
+    # @param [Lambda] query
+    #
+    # @return [Array]
+    #
+    def steps(query = DEFAULT_QUERY)
+      @steps.select do |step|
+        query.call(step)
+      end
+    end
+  end
+end

data/lib/gene_system/platform.rb

@@ -0,0 +1,55 @@
+require 'os'
+require 'ruby-handlebars'
+
+module GeneSystem
+  # Platform is a class to handle command execution on host system
+  class Platform
+    ##
+    # Platform constructor. Raises unsupported platform RuntimeError
+    # when the host system is not a posix system.
+    #
+    def initialize
+      raise 'unsupported platform' unless posix?
+    end
+
+    ##
+    # Takes an array of commands for the host and executes each one
+    #
+    # If command returns non zero status code, then a command failed
+    # RuntimeError will be raised
+    #
+    # @param[Array] cmds
+    #
+    def execute_commands(cmds = [], vars = {})
+      cmds.each do |cmd|
+        status = execute_command(cmd, vars)
+        raise "command `#{cmd}` failed - returned #{status}" unless status.zero?
+      end
+    end
+
+    ##
+    # Executes a command on a host system and returns command exit code
+    #
+    # @param [String] cmd
+    #
+    # @return [Integer]
+    def execute_command(cmd, vars = {})
+      hbs = Handlebars::Handlebars.new
+
+      pid = Process.spawn(hbs.compile(cmd).call(vars))
+      _, status = Process.waitpid2(pid)
+
+      status.exitstatus
+    end
+
+    ##
+    # Posix platform check. Returns true if host is a posix system
+    # i.e. Mac/Linux etc.
+    #
+    # @return [Boolean]
+    #
+    def posix?
+      OS.posix?
+    end
+  end
+end

data/lib/gene_system/step.rb

@@ -0,0 +1,74 @@
+require 'hashie'
+
+module GeneSystem
+  # Step is an in memory representation of a manifest step
+  class Step
+    class <<self
+      ##
+      # Loads steps from an array of steps
+      #
+      # @param [Array] steps
+      #
+      # @return [Array]
+      #
+      def load_steps(steps)
+        steps.map do |data|
+          new(data)
+        end
+      end
+    end
+
+    attr_reader :tags
+
+    def initialize(data)
+      @data = Hashie::Mash.new(data)
+      @tags = []
+      @tags = @data.tags.split("\s") if @data.tags
+    end
+
+    ##
+    # Step name getter
+    #
+    # @return [String]
+    #
+    def name
+      @data.name
+    end
+
+    ##
+    # Step prompt getter
+    #
+    # @return [Array]
+    #
+    def prompts
+      @data.prompts
+    end
+
+    ##
+    # Step execution instructions getter
+    #
+    # @return [Hash]
+    #
+    def exe
+      @data.exe
+    end
+
+    ##
+    # Installation instructions getter
+    #
+    # @return [Array]
+    #
+    def install
+      exe.install
+    end
+
+    ##
+    # Removal instructions getter
+    #
+    # @return [Array]
+    #
+    def remove
+      exe.remove
+    end
+  end
+end

data/lib/gene_system/version.rb

@@ -0,0 +1,3 @@
+module GeneSystem
+  VERSION = '0.3.2'.freeze
+end

data/spec/gene_system/cli/commands_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+RSpec.describe GeneSystem::CLI::Commands do
+  describe '.new' do
+    let(:pwd) { 'path/to/current/dir' }
+    let(:name) { 'manifest name' }
+    let(:args) { [name] }
+
+    before do
+      allow(Dir).to receive(:pwd).and_return(pwd)
+      allow(GeneSystem::Generators).to receive(:render_empty_manifest)
+    end
+
+    it 'renders empty manifest at current path with given name' do
+      described_class.new(args)
+
+      expect(GeneSystem::Generators).to have_received(:render_empty_manifest)
+        .with(name, pwd)
+    end
+
+    context 'when name is not given' do
+      it 'raises no manifest name provided runtime error' do
+        expect { described_class.new([]) }.to raise_error(
+          RuntimeError,
+          'no manifest name provided'
+        )
+      end
+    end
+  end
+
+  describe '.install' do
+    let(:manifest_name) { 'manifest.json' }
+    let(:pwd) { 'path/to/current/dir' }
+
+    let(:args) { [manifest_name] }
+    let(:file_exist) { true }
+
+    let(:skip_cmd) { 'check something' }
+    let(:skip_result) { 1 }
+
+    let(:cmd) { 'do something' }
+    let(:cmds) { [cmd, cmd] }
+
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'steps' => [
+          {
+            'name' => 'install',
+            'exe' => {
+              'install' => {
+                'skip' => skip_cmd,
+                'cmd' => cmds
+              }
+            }
+          }
+        ]
+      }
+    end
+
+    let(:manifest) do
+      GeneSystem::Manifest.new(
+        File.join(pwd, manifest_name),
+        data
+      )
+    end
+    let(:platform) { double(GeneSystem::Platform) }
+
+    before do
+      allow(Dir).to receive(:pwd).and_return(pwd)
+      allow(File).to receive(:exist?).and_return(file_exist)
+
+      allow(GeneSystem::Manifest).to receive(:new_from_file)
+        .and_return(manifest)
+
+      allow(GeneSystem::Platform).to receive(:new)
+        .and_return(platform)
+
+      allow(platform).to receive(:execute_commands)
+      allow(platform).to receive(:execute_command)
+        .with(skip_cmd)
+        .and_return(skip_result)
+
+      allow(GeneSystem::CLI).to receive(:print_message)
+    end
+
+    describe 'installing manifest' do
+      before { described_class.install(args) }
+
+      it 'loads manifest' do
+        expect(GeneSystem::Manifest)
+          .to have_received(:new_from_file)
+          .with(File.join(pwd, manifest_name))
+      end
+
+      it 'executes steps on platform' do
+        expect(platform)
+          .to have_received(:execute_commands)
+          .with(cmds, {})
+      end
+
+      it 'prints success message' do
+        expect(GeneSystem::CLI).to have_received(:print_message)
+          .with("\nmanifest successfully installed")
+      end
+
+      context 'when skipping step' do
+        let(:skip_result) { 0 }
+
+        it 'does not execute steps' do
+          expect(platform)
+            .not_to have_received(:execute_commands)
+        end
+      end
+    end
+
+    context 'when path is not provided' do
+      it 'raises no manifest path provided runtime error' do
+        expect { described_class.install }.to raise_error(
+          RuntimeError,
+          'no manifest path provided'
+        )
+      end
+    end
+
+    context 'when manifest cannot be created at specified path' do
+      let(:file_exist) { false }
+
+      it 'raises cannot find manifest RuntimeError' do
+        expect { described_class.install(args) }.to raise_error(
+          RuntimeError,
+          'cannot find manifest at path/to/current/dir/manifest.json'
+        )
+      end
+    end
+  end
+
+  describe '.remove' do
+    let(:manifest_name) { 'manifest.json' }
+    let(:pwd) { 'path/to/current/dir' }
+
+    let(:args) { [manifest_name] }
+    let(:file_exist) { true }
+
+    let(:cmd) { 'do something' }
+    let(:cmds) { [cmd, cmd] }
+
+    let(:data) do
+      {
+        'name' => 'test_manifest',
+        'version' => '0.1.0',
+        'steps' => [
+          {
+            'name' => 'remove',
+            'exe' => {
+              'remove' => {
+                'cmd' => cmds
+              }
+            }
+          }
+        ]
+      }
+    end
+
+    let(:manifest) do
+      GeneSystem::Manifest.new(
+        File.join(pwd, manifest_name),
+        data
+      )
+    end
+    let(:platform) { double(GeneSystem::Platform) }
+
+    before do
+      allow(Dir).to receive(:pwd).and_return(pwd)
+      allow(File).to receive(:exist?).and_return(file_exist)
+
+      allow(GeneSystem::Manifest).to receive(:new_from_file)
+        .and_return(manifest)
+
+      allow(GeneSystem::Platform).to receive(:new)
+        .and_return(platform)
+
+      allow(platform).to receive(:execute_commands)
+
+      allow(GeneSystem::CLI).to receive(:print_message)
+    end
+
+    describe 'remooving manifest' do
+      before { described_class.remove(args) }
+
+      it 'loads manifest' do
+        expect(GeneSystem::Manifest)
+          .to have_received(:new_from_file)
+          .with(File.join(pwd, manifest_name))
+      end
+
+      it 'executes remove on platform' do
+        expect(platform)
+          .to have_received(:execute_commands)
+          .with(cmds)
+      end
+
+      it 'prints success message' do
+        expect(GeneSystem::CLI).to have_received(:print_message)
+          .with("\nmanifest successfully removed")
+      end
+    end
+
+    context 'when path is not provided' do
+      it 'raises no manifest path provided runtime error' do
+        expect { described_class.install }.to raise_error(
+          RuntimeError,
+          'no manifest path provided'
+        )
+      end
+    end
+
+    context 'when manifest cannot be created at specified path' do
+      let(:file_exist) { false }
+
+      it 'raises cannot find manifest RuntimeError' do
+        expect { described_class.install(args) }.to raise_error(
+          RuntimeError,
+          'cannot find manifest at path/to/current/dir/manifest.json'
+        )
+      end
+    end
+  end
+end