lino 3.2.0.pre.5 → 3.2.0.pre.6

data/lib/lino/model.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'model/command_line'
+require_relative 'model/subcommand'
+require_relative 'model/option'
+require_relative 'model/flag'
+require_relative 'model/argument'
+require_relative 'model/environment_variable'
+
+module Lino
+  module Model
+  end
+end

data/lib/lino/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lino
-  VERSION = '3.2.0.pre.5'
+  VERSION = '3.2.0.pre.6'
 end

data/lib/lino.rb

@@ -1,8 +1,17 @@
 # frozen_string_literal: true
 
 require 'lino/version'
-require 'lino/command_line'
-require 'lino/command_line_builder'
+require 'lino/model'
+require 'lino/builders'
+require 'lino/executors'
+require 'lino/errors'
 
 module Lino
+  class CommandLineBuilder
+    class << self
+      def for_command(command)
+        Lino::Builders::CommandLine.new(command:)
+      end
+    end
+  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lino
 version: !ruby/object:Gem::Version
-  version: 3.2.0.pre.5
+  version: 3.2.0.pre.6
 platform: ruby
 authors:
 - InfraBlocks Maintainers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-06 00:00:00.000000000 Z
+date: 2024-07-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
   name: hamster
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -250,12 +292,32 @@ files:
 - bin/console
 - bin/setup
 - lib/lino.rb
-- lib/lino/appliables.rb
-- lib/lino/command_line.rb
-- lib/lino/command_line_builder.rb
-- lib/lino/options.rb
-- lib/lino/subcommand_builder.rb
-- lib/lino/utilities.rb
+- lib/lino/builders.rb
+- lib/lino/builders/command_line.rb
+- lib/lino/builders/mixins/appliables.rb
+- lib/lino/builders/mixins/arguments.rb
+- lib/lino/builders/mixins/defaulting.rb
+- lib/lino/builders/mixins/environment_variables.rb
+- lib/lino/builders/mixins/executor.rb
+- lib/lino/builders/mixins/option_config.rb
+- lib/lino/builders/mixins/options.rb
+- lib/lino/builders/mixins/state_boundary.rb
+- lib/lino/builders/mixins/subcommands.rb
+- lib/lino/builders/mixins/validation.rb
+- lib/lino/builders/mixins/working_directory.rb
+- lib/lino/builders/subcommand.rb
+- lib/lino/errors.rb
+- lib/lino/errors/execution_error.rb
+- lib/lino/executors.rb
+- lib/lino/executors/childprocess.rb
+- lib/lino/executors/open4.rb
+- lib/lino/model.rb
+- lib/lino/model/argument.rb
+- lib/lino/model/command_line.rb
+- lib/lino/model/environment_variable.rb
+- lib/lino/model/flag.rb
+- lib/lino/model/option.rb
+- lib/lino/model/subcommand.rb
 - lib/lino/version.rb
 homepage: https://github.com/infrablocks/lino
 licenses:
@@ -270,14 +332,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Command line execution utilities

data/lib/lino/appliables.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'utilities'
-
-module Lino
-  module Appliables
-    include Lino::Utilities
-
-    def with_appliable(appliable)
-      return self if nil?(appliable)
-
-      appliable.apply(self)
-    end
-
-    def with_appliables(appliables)
-      return self if nil_or_empty?(appliables)
-
-      appliables.inject(self) do |s, appliable|
-        s.with_appliable(appliable)
-      end
-    end
-  end
-end

data/lib/lino/command_line.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'open4'
-
-module Lino
-  class CommandLine
-    def initialize(command_line)
-      @command_line = command_line
-    end
-
-    def execute(
-      stdin: '',
-      stdout: $stdout,
-      stderr: $stderr
-    )
-      Open4.spawn(
-        @command_line,
-        stdin: stdin,
-        stdout: stdout,
-        stderr: stderr
-      )
-    end
-
-    def to_s
-      @command_line
-    end
-  end
-end

data/lib/lino/command_line_builder.rb

@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-
-require 'hamster'
-require_relative 'utilities'
-require_relative 'command_line'
-require_relative 'subcommand_builder'
-require_relative 'options'
-require_relative 'appliables'
-
-module Lino
-  # rubocop:disable Metrics/ClassLength
-  class CommandLineBuilder
-    include Lino::Utilities
-    include Lino::Options
-    include Lino::Appliables
-
-    class << self
-      def for_command(command)
-        CommandLineBuilder.new(command: command)
-      end
-    end
-
-    # rubocop:disable Metrics/ParameterLists
-    def initialize(
-      command: nil,
-      subcommands: [],
-      options: [],
-      arguments: [],
-      environment_variables: [],
-      option_separator: ' ',
-      option_quoting: nil,
-      option_placement: :after_command
-    )
-      @command = command
-      @subcommands = Hamster::Vector.new(subcommands)
-      @options = Hamster::Vector.new(options)
-      @arguments = Hamster::Vector.new(arguments)
-      @environment_variables = Hamster::Vector.new(environment_variables)
-      @option_separator = option_separator
-      @option_quoting = option_quoting
-      @option_placement = option_placement
-    end
-
-    # rubocop:enable Metrics/ParameterLists
-
-    def with_subcommand(subcommand, &block)
-      return self if nil?(subcommand)
-
-      with(
-        subcommands: @subcommands.add(
-          (block || ->(sub) { sub }).call(
-            SubcommandBuilder.for_subcommand(subcommand)
-          )
-        )
-      )
-    end
-
-    def with_subcommands(subcommands, &block)
-      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, &block)
-    end
-
-    def with_option_separator(option_separator)
-      with(option_separator: option_separator)
-    end
-
-    def with_option_quoting(character)
-      with(option_quoting: character)
-    end
-
-    def with_option_placement(option_placement)
-      with(option_placement: option_placement)
-    end
-
-    def with_options_after_command
-      with_option_placement(:after_command)
-    end
-
-    def with_options_after_subcommands
-      with_option_placement(:after_subcommands)
-    end
-
-    def with_options_after_arguments
-      with_option_placement(:after_arguments)
-    end
-
-    def with_argument(argument)
-      return self if nil?(argument)
-
-      with(arguments: @arguments.add({ components: [argument] }))
-    end
-
-    def with_arguments(arguments)
-      return self if nil_or_empty?(arguments)
-
-      arguments.inject(self) { |s, argument| s.with_argument(argument) }
-    end
-
-    def with_environment_variable(environment_variable, value)
-      with(
-        environment_variables:
-          @environment_variables.add(
-            [
-              environment_variable, value
-            ]
-          )
-      )
-    end
-
-    def with_environment_variables(environment_variables)
-      return self if nil_or_empty?(environment_variables)
-
-      environment_variables.entries.inject(self) do |s, var|
-        s.with_environment_variable(
-          var.include?(:name) ? var[:name] : var[0],
-          var.include?(:value) ? var[:value] : var[1]
-        )
-      end
-    end
-
-    def build
-      components = formatted_components
-      command_line =
-        component_paths
-        .collect { |path| path.inject(components) { |c, p| c && c[p] } }
-        .reject(&:empty?)
-        .join(' ')
-
-      CommandLine.new(command_line)
-    end
-
-    private
-
-    def component_paths
-      [
-        %i[environment_variables],
-        %i[command],
-        %i[options after_command],
-        %i[subcommands],
-        %i[options after_subcommands],
-        %i[arguments],
-        %i[options after_arguments]
-      ]
-    end
-
-    def formatted_components
-      {
-        environment_variables: formatted_environment_variables,
-        command: @command,
-        options: formatted_options,
-        subcommands: formatted_subcommands,
-        arguments: formatted_arguments
-      }
-    end
-
-    def formatted_environment_variables
-      map_and_join(@environment_variables) do |var|
-        "#{var[0]}=\"#{var[1].to_s.gsub('"', '\\"')}\""
-      end
-    end
-
-    def formatted_options_with_placement(placement)
-      map_and_join(
-        options_with_placement(placement),
-        &(quote_with(@option_quoting) >> join_with(@option_separator))
-      )
-    end
-
-    def formatted_options
-      %i[
-        after_command
-        after_subcommands
-        after_arguments
-      ].inject({}) do |options, placement|
-        options
-          .merge({ placement => formatted_options_with_placement(placement) })
-      end
-    end
-
-    def formatted_subcommands
-      map_and_join(@subcommands) do |sub|
-        sub.build(@option_separator, @option_quoting)
-      end
-    end
-
-    def formatted_arguments
-      map_and_join(
-        @arguments,
-        &join_with(' ')
-      )
-    end
-
-    def options_with_placement(placement)
-      @options.select { |o| o[:placement] == placement } +
-        if @option_placement == placement
-          @options.select { |o| o[:placement].nil? }
-        end
-    end
-
-    def with(**replacements)
-      CommandLineBuilder.new(**state.merge(replacements))
-    end
-
-    def state
-      {
-        command: @command,
-        subcommands: @subcommands,
-        options: @options,
-        arguments: @arguments,
-        environment_variables: @environment_variables,
-        option_separator: @option_separator,
-        option_quoting: @option_quoting,
-        option_placement: @option_placement
-      }
-    end
-  end
-
-  # rubocop:enable Metrics/ClassLength
-end

data/lib/lino/options.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'utilities'
-
-module Lino
-  module Options
-    include Lino::Utilities
-
-    def with_option(
-      option,
-      value,
-      separator: nil,
-      quoting: nil,
-      placement: nil
-    )
-      return self if nil?(value)
-
-      with(options: @options.add(
-        {
-          components: [option, value],
-          separator: separator,
-          quoting: quoting,
-          placement: placement
-        }
-      ))
-    end
-
-    def with_options(options)
-      return self if nil_or_empty?(options)
-
-      options.entries.inject(self) do |s, entry|
-        s.with_option(
-          or_nth(entry, :option, 0),
-          or_nth(entry, :value, 1),
-          separator: or_nil(entry, :separator),
-          quoting: or_nil(entry, :quoting),
-          placement: or_nil(entry, :placement)
-        )
-      end
-    end
-
-    def with_repeated_option(
-      option,
-      values,
-      separator: nil,
-      quoting: nil,
-      placement: nil
-    )
-      values.inject(self) do |s, value|
-        s.with_option(
-          option,
-          value,
-          separator: separator,
-          quoting: quoting,
-          placement: placement
-        )
-      end
-    end
-
-    def with_flag(flag)
-      return self if nil?(flag)
-
-      with(options: @options.add({ components: [flag] }))
-    end
-
-    def with_flags(flags)
-      return self if nil_or_empty?(flags)
-
-      flags.inject(self) { |s, flag| s.with_flag(flag) }
-    end
-  end
-end

data/lib/lino/subcommand_builder.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'hamster'
-require_relative 'utilities'
-require_relative 'options'
-require_relative 'appliables'
-
-module Lino
-  class SubcommandBuilder
-    include Lino::Utilities
-    include Lino::Options
-    include Lino::Appliables
-
-    class << self
-      def for_subcommand(subcommand)
-        SubcommandBuilder.new(subcommand: subcommand)
-      end
-    end
-
-    def initialize(subcommand: nil, options: [])
-      @subcommand = subcommand
-      @options = Hamster::Vector.new(options)
-    end
-
-    def build(option_separator, option_quoting)
-      components = [
-        @subcommand,
-        map_and_join(
-          @options,
-          &(quote_with(option_quoting) >> join_with(option_separator))
-        )
-      ]
-      components.reject(&:empty?).join(' ')
-    end
-
-    private
-
-    def with(**replacements)
-      SubcommandBuilder.new(**state.merge(replacements))
-    end
-
-    def state
-      {
-        subcommand: @subcommand,
-        options: @options
-      }
-    end
-  end
-end

data/lib/lino/utilities.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Lino
-  module Utilities
-    def map_and_join(collection, &block)
-      collection.map { |item| block.call(item) }.join(' ')
-    end
-
-    def join_with(global_separator)
-      lambda do |item|
-        item[:components].join(item[:separator] || global_separator)
-      end
-    end
-
-    def quote_with(global_character)
-      lambda do |item|
-        item.merge(
-          components: resolve_components(item, global_character)
-        )
-      end
-    end
-
-    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
-
-    private
-
-    def resolve_components(item, global_character)
-      components = item[:components]
-      switch = components[0]
-
-      if components.count > 1
-        character = item[:quoting] || global_character
-        value = components[1]
-
-        [switch, "#{character}#{value}#{character}"]
-      else
-        components
-      end
-    end
-
-    def or_nil(enumerable, key)
-      enumerable.include?(key) ? enumerable[key] : nil
-    end
-
-    def or_nth(enumerable, key, index)
-      enumerable.include?(key) ? enumerable[key] : enumerable[index]
-    end
-  end
-end