lino 3.2.0.pre.5 → 3.2.0.pre.7

data/lib/lino/builders/mixins/subcommands.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'validation'
+require_relative '../../model'
+
+module Lino
+  module Builders
+    module Mixins
+      module Subcommands
+        include Validation
+
+        def initialize(state)
+          @subcommands = Hamster::Vector.new(state[:subcommands] || [])
+          super
+        end
+
+        def with_subcommand(subcommand, &block)
+          return self if nil_or_empty?(subcommand)
+
+          with(
+            subcommands: @subcommands.add(
+              (block || ->(sub) { sub }).call(
+                Builders::Subcommand.for_subcommand(subcommand)
+              )
+            )
+          )
+        end
+
+        def with_subcommands(subcommands, &)
+          return self if nil_or_empty?(subcommands)
+
+          without_block = subcommands[0...-1]
+          with_block = subcommands.last
+
+          without_block
+            .inject(self) { |s, sc| s.with_subcommand(sc) }
+            .with_subcommand(with_block, &)
+        end
+
+        private
+
+        def state
+          super.merge(subcommands: @subcommands)
+        end
+
+        def build_subcommands
+          @subcommands.map(&:build)
+        end
+      end
+    end
+  end
+end

data/lib/lino/builders/mixins/validation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lino
+  module Builders
+    module Mixins
+      module Validation
+        def nil?(value)
+          value.nil?
+        end
+
+        def empty?(value)
+          value.respond_to?(:empty?) && value.empty?
+        end
+
+        def nil_or_empty?(value)
+          nil?(value) || empty?(value)
+        end
+      end
+    end
+  end
+end

data/lib/lino/builders/mixins/working_directory.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lino
+  module Builders
+    module Mixins
+      module WorkingDirectory
+        def initialize(state)
+          @working_directory = state[:working_directory]
+          super
+        end
+
+        def with_working_directory(working_directory)
+          with(working_directory:)
+        end
+
+        private
+
+        def state
+          super.merge(working_directory: @working_directory)
+        end
+      end
+    end
+  end
+end

data/lib/lino/builders/subcommand.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'hamster'
+
+require_relative '../model'
+require_relative 'mixins/options'
+require_relative 'mixins/appliables'
+
+module Lino
+  module Builders
+    class Subcommand
+      include Mixins::Options
+      include Mixins::Appliables
+
+      class << self
+        def for_subcommand(subcommand)
+          Builders::Subcommand.new(subcommand:)
+        end
+      end
+
+      def initialize(state)
+        @subcommand = state[:subcommand]
+        @options = Hamster::Vector.new(state[:options] || [])
+      end
+
+      def build
+        Model::Subcommand.new(
+          @subcommand,
+          options: build_options
+        )
+      end
+
+      private
+
+      def with(replacements)
+        Builders::Subcommand.new(state.merge(replacements))
+      end
+
+      def state
+        {
+          subcommand: @subcommand,
+          options: @options
+        }
+      end
+    end
+  end
+end

data/lib/lino/builders.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'builders/command_line'
+require_relative 'builders/subcommand'
+
+module Lino
+  module Builders
+  end
+end

data/lib/lino/errors/execution_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Lino
+  module Errors
+    class ExecutionError < StandardError
+      def initialize(
+        command_line = nil,
+        exit_code = nil,
+        cause = nil
+      )
+        @command_line = command_line
+        @exit_code = exit_code
+        @cause = cause
+        super('Failed while executing command line.')
+      end
+    end
+  end
+end

data/lib/lino/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'errors/execution_error'
+
+module Lino
+  module Errors
+  end
+end

data/lib/lino/executors/childprocess.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'childprocess'
+
+require_relative '../errors'
+
+module Lino
+  module Executors
+    class Childprocess
+      def execute(command_line, opts = {})
+        process = ::ChildProcess.build(*command_line.array)
+
+        set_output_streams(process, opts)
+        set_working_directory(process, command_line.working_directory)
+        set_environment(process, command_line.environment_variables)
+        start_process(process, opts)
+
+        exit_code = process.wait
+
+        return if exit_code.zero?
+
+        raise Lino::Errors::ExecutionError.new(
+          command_line.string, exit_code
+        )
+      end
+
+      def ==(other)
+        self.class == other.class
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash
+      end
+
+      private
+
+      def start_process(process, opts)
+        process.duplex = true if opts[:stdin]
+        process.start
+        process.io.stdin.write(opts[:stdin]) if opts[:stdin]
+      end
+
+      def set_output_streams(process, opts)
+        process.io.inherit!
+        process.io.stdout = opts[:stdout] if opts[:stdout]
+        process.io.stderr = opts[:stderr] if opts[:stderr]
+      end
+
+      def set_working_directory(process, working_directory)
+        process.cwd = working_directory
+      end
+
+      def set_environment(process, environment_variables)
+        environment_variables.each do |environment_variable|
+          process.environment[environment_variable.name] =
+            environment_variable.value
+        end
+      end
+    end
+  end
+end

data/lib/lino/executors/mock.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lino
+  module Executors
+    class Mock
+      attr_reader :calls
+      attr_accessor :exit_code
+
+      def initialize
+        reset
+      end
+
+      def execute(command_line, opts = {})
+        @calls << { command_line:, opts:, exit_code: @exit_code }
+
+        return if @exit_code.zero?
+
+        raise Lino::Errors::ExecutionError.new(
+          command_line.string, @exit_code
+        )
+      end
+
+      def reset
+        @calls = []
+        @exit_code = 0
+      end
+    end
+  end
+end

data/lib/lino/executors/open4.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'open4'
+
+module Lino
+  module Executors
+    class Open4
+      def execute(command_line, opts = {})
+        opts = with_defaults(opts)
+
+        ::Open4.spawn(
+          command_line.env,
+          *command_line.array,
+          stdin: opts[:stdin],
+          stdout: opts[:stdout],
+          stderr: opts[:stderr],
+          cwd: command_line.working_directory
+        )
+      end
+
+      def ==(other)
+        self.class == other.class
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash
+      end
+
+      private
+
+      def with_defaults(opts)
+        {
+          stdin: opts[:stdin] || '',
+          stdout: opts[:stdout] || $stdout,
+          stderr: opts[:stderr] || $stderr
+        }
+      end
+    end
+  end
+end

data/lib/lino/executors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'executors/open4'
+require_relative 'executors/childprocess'
+require_relative 'executors/mock'
+
+module Lino
+  module Executors
+  end
+end

data/lib/lino/model/argument.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Lino
+  module Model
+    class Argument
+      attr_reader :argument
+
+      def initialize(argument)
+        @argument = argument
+      end
+
+      def string
+        argument
+      end
+      alias to_s string
+
+      def array
+        [argument]
+      end
+      alias to_a string
+
+      def ==(other)
+        self.class == other.class &&
+          state == other.state
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, state].hash
+      end
+
+      protected
+
+      def state
+        [
+          @argument
+        ]
+      end
+    end
+  end
+end

data/lib/lino/model/command_line.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Lino
+  module Model
+    class CommandLine
+      COMPONENTS = [
+        %i[environment_variables],
+        %i[command],
+        %i[options after_command],
+        %i[subcommands],
+        %i[options after_subcommands],
+        %i[arguments],
+        %i[options after_arguments]
+      ].freeze
+
+      attr_reader :command,
+                  :subcommands,
+                  :options,
+                  :arguments,
+                  :environment_variables,
+                  :executor,
+                  :working_directory
+
+      def initialize(command, opts = {})
+        opts = with_defaults(opts)
+        @command = command
+        @subcommands = Hamster::Vector.new(opts[:subcommands])
+        @options = Hamster::Vector.new(opts[:options])
+        @arguments = Hamster::Vector.new(opts[:arguments])
+        @environment_variables =
+          Hamster::Vector.new(opts[:environment_variables])
+        @executor = opts[:executor]
+        @working_directory = opts[:working_directory]
+      end
+
+      def execute(opts = {})
+        @executor.execute(self, opts)
+      end
+
+      def env
+        @environment_variables.to_h(&:array)
+      end
+
+      def array
+        format_components(:array, COMPONENTS.drop(1)).flatten
+      end
+
+      alias to_a array
+
+      def string
+        format_components(:string, COMPONENTS).join(' ')
+      end
+
+      alias to_s string
+
+      def ==(other)
+        self.class == other.class && state == other.state
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, state].hash
+      end
+
+      protected
+
+      def state
+        [
+          @command,
+          @subcommands,
+          @options,
+          @arguments,
+          @environment_variables,
+          @executor,
+          @working_directory
+        ]
+      end
+
+      private
+
+      def with_defaults(opts)
+        {
+          subcommands: opts.fetch(:subcommands, []),
+          options: opts.fetch(:options, []),
+          arguments: opts.fetch(:arguments, []),
+          environment_variables: opts.fetch(:environment_variables, []),
+          executor: opts.fetch(:executor, Lino.configuration.executor),
+          working_directory: opts.fetch(:working_directory, nil)
+        }
+      end
+
+      def format_components(format, paths)
+        paths
+          .collect { |p| components_at_path(formatted_components(format), p) }
+          .compact
+          .reject(&:empty?)
+      end
+
+      def formatted_components(format)
+        {
+          environment_variables: @environment_variables.map(&format),
+          command: @command,
+          options: @options
+            .group_by(&:placement)
+            .map { |p, o| [p, o.map(&format)] },
+          subcommands: @subcommands.map(&format),
+          arguments: @arguments.map(&format)
+        }
+      end
+
+      def components_at_path(components, path)
+        path.inject(components) { |c, p| c && c[p] }
+      end
+    end
+  end
+end

data/lib/lino/model/environment_variable.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Lino
+  module Model
+    class EnvironmentVariable
+      attr_reader :name,
+                  :value,
+                  :quoting
+
+      def initialize(name, value, opts = {})
+        opts = with_defaults(opts)
+        @name = name
+        @value = value
+        @quoting = opts[:quoting]
+      end
+
+      def quoted_value
+        "#{quoting}#{value.to_s.gsub(quoting.to_s, "\\#{quoting}")}#{quoting}"
+      end
+
+      def string
+        "#{name}=#{quoted_value}"
+      end
+      alias to_s string
+
+      def array
+        [name, value]
+      end
+      alias to_a array
+
+      def ==(other)
+        self.class == other.class &&
+          state == other.state
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, state].hash
+      end
+
+      protected
+
+      def state
+        [
+          @name,
+          @value,
+          @quoting
+        ]
+      end
+
+      private
+
+      def with_defaults(opts)
+        {
+          quoting: opts[:quoting] || '"'
+        }
+      end
+    end
+  end
+end

data/lib/lino/model/flag.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Lino
+  module Model
+    class Flag
+      attr_reader :flag,
+                  :placement
+
+      def initialize(flag, opts = {})
+        opts = with_defaults(opts)
+        @flag = flag
+        @placement = opts[:placement]
+      end
+
+      def string
+        flag
+      end
+      alias to_s string
+
+      def array
+        [flag]
+      end
+      alias to_a string
+
+      def ==(other)
+        self.class == other.class &&
+          state == other.state
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, state].hash
+      end
+
+      protected
+
+      def state
+        [
+          @flag,
+          @placement
+        ]
+      end
+
+      private
+
+      def with_defaults(opts)
+        {
+          placement: opts[:placement] || :after_command
+        }
+      end
+    end
+  end
+end

data/lib/lino/model/option.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Lino
+  module Model
+    class Option
+      attr_reader :option,
+                  :value,
+                  :separator,
+                  :quoting,
+                  :placement
+
+      def initialize(option, value, opts = {})
+        opts = with_defaults(opts)
+        @option = option
+        @value = value
+        @separator = opts[:separator]
+        @quoting = opts[:quoting]
+        @placement = opts[:placement]
+      end
+
+      def quoted_value
+        "#{quoting}#{value}#{quoting}"
+      end
+
+      def string
+        "#{option}#{separator}#{quoted_value}"
+      end
+      alias to_s string
+
+      def array
+        if separator == ' '
+          [option, value]
+        else
+          ["#{option}#{separator}#{value}"]
+        end
+      end
+      alias to_a array
+
+      def ==(other)
+        self.class == other.class &&
+          state == other.state
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, state].hash
+      end
+
+      protected
+
+      def state
+        [
+          @option,
+          @value,
+          @separator,
+          @quoting,
+          @placement
+        ]
+      end
+
+      private
+
+      def with_defaults(opts)
+        {
+          separator: opts[:separator] || ' ',
+          quoting: opts[:quoting],
+          placement: opts[:placement] || :after_command
+        }
+      end
+    end
+  end
+end