ruby_vault 0.1.0.pre.2 → 0.1.0.pre.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 517ba1189e0acf38b729072d2f4a79ff4d22e0d7630d22d7933d0e33eb2ef04f
-  data.tar.gz: e70f30492b24464cf6505ac87fc040070c9915abb08a8696d66b3caa41440c31
+  metadata.gz: fb03f600d2c47bd04285941594a82ef4f3e0db9b8fc7e5092326f96fbaca5e9e
+  data.tar.gz: 0b83a87b3ab6690737170e14aab376e83ef519df45d25c75c49fc86789b85be9
 SHA512:
-  metadata.gz: d1aa3226f32c5f59acdfba7d0cfab67e71e10d8cbe9912f45ac18a54cca8df93912ebfe09b3897b8a47687e4301a818b01b6778a3ae1c2ac89cfa7564a3f445d
-  data.tar.gz: 83577b10a67ea70167fdb434ebaa3fb81c55538a82a2e748f6b0ac2fff857f5f78984a356a488fdae00e65e4bc100e989e0d84c2a168aef7d211d0c0cfce441a
+  metadata.gz: 120ebda0f8284dfbd8fb8995554953725022f60aa8ccb114e060bfaca71c836e19907c2954f15f41876c9ea8ecd51bb22910aecf9d8472025850a7c383fbad78
+  data.tar.gz: dd6e94ffb5afeeffba98af0b8df0e9c992c772ea62b5524032862f9249c74959767d3985d37da1354116f1ea7243963878b2e3d824c457521f70ae3be8f69613

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby_vault (0.1.0.pre.2)
+    ruby_vault (0.1.0.pre.5)
       immutable-struct (~> 2.4)
       lino (~> 3.0)
 
@@ -115,7 +115,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
-    rubocop (1.32.0)
+    rubocop (1.33.0)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.1.0.0)

data/lib/ruby_vault/commands/base.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'lino'
+
+require_relative '../errors'
+
+module RubyVault
+  module Commands
+    class Base
+      # rubocop:disable Metrics/AbcSize
+
+      # Constructs an instance of the command.
+      #
+      def initialize(**opts)
+        @binary  = opts[:binary]  || RubyVault.configuration.binary
+        @logger  = opts[:logger]  || RubyVault.configuration.logger
+        @options = opts[:options] || RubyVault.configuration.options
+        @stdin   = opts[:stdin]   || RubyVault.configuration.stdin
+        @stdout  = opts[:stdout]  || RubyVault.configuration.stdout
+        @stderr  = opts[:stderr]  || RubyVault.configuration.stderr
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      # Executes the command instance.
+      #
+      # @param [Hash<String, Object>] parameters The parameters used to
+      #   invoke the command. See subclass documentation for details of
+      #   supported options.
+      # @param [Hash<String, Object>] invocation_options Additional options
+      #   controlling the invocation of the command.
+      # @option invocation_options [Hash<String, String>] :environment A map
+      #   of environment variables to expose at command invocation time.
+      def execute(parameters = {}, invocation_options = {})
+        do_before(parameters)
+        build_and_execute_command(parameters, invocation_options)
+        do_after(parameters)
+      rescue Open4::SpawnError
+        message = "Failed while running '#{command_name}'."
+        logger.error(message)
+        raise Errors::ExecutionError, message
+      end
+
+      protected
+
+      attr_reader :binary, :logger, :stdin, :stdout, :stderr
+
+      def build_and_execute_command(parameters, invocation_options)
+        command = build_command(parameters, invocation_options)
+
+        logger.debug("Running '#{command}'.")
+        command.execute(
+          stdin: stdin,
+          stdout: stdout,
+          stderr: stderr
+        )
+      end
+
+      def command_name
+        self.class.to_s.split('::')[-1].downcase
+      end
+
+      def do_before(_parameters); end
+
+      def do_after(_parameters); end
+
+      private
+
+      def build_command(parameters, invocation_options)
+        parameters = resolve_parameters(parameters)
+        environment = invocation_options[:environment] || {}
+
+        Lino::CommandLineBuilder
+          .for_command(@binary)
+          .with_environment_variables(environment)
+          .with_options_after_subcommands
+          .with_option_separator('=')
+          .with_appliables(@options.resolve(options, parameters))
+          .with_subcommands(subcommands)
+          .with_arguments(arguments(parameters).compact.flatten).build
+      end
+
+      def resolve_parameters(parameters)
+        parameter_defaults(parameters)
+          .merge(parameters)
+          .merge(parameter_overrides(parameters))
+      end
+
+      def parameter_defaults(_parameters)
+        {}
+      end
+
+      def parameter_overrides(_parameters)
+        {}
+      end
+
+      def subcommands
+        []
+      end
+
+      def options
+        []
+      end
+
+      def arguments(_parameters)
+        []
+      end
+    end
+  end
+end

data/lib/ruby_vault/commands/login.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RubyVault
+  module Commands
+    class Login < Base
+      # @!visibility private
+      def subcommands
+        %w[login]
+      end
+
+      # @!visibility private
+      def options
+        %w[
+          -method
+        ] + super
+      end
+    end
+  end
+end

data/lib/ruby_vault/commands/write.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RubyVault
+  module Commands
+    class Write < Base
+      # @!visibility private
+      def subcommands
+        %w[write]
+      end
+
+      # @!visibility private
+      def options
+        %w[] + super
+      end
+
+      # @!visibility private
+      def arguments(parameters)
+        [parameters[:path]]
+      end
+    end
+  end
+end

data/lib/ruby_vault/commands.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'commands/login'
+require_relative 'commands/write'
+
+module RubyVault
+  module Commands
+  end
+end

data/lib/ruby_vault/errors/execution_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RubyVault
+  module Errors
+    class ExecutionError < StandardError
+    end
+  end
+end

data/lib/ruby_vault/errors.rb

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

data/lib/ruby_vault/options/definition.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'immutable-struct'
+
+require_relative 'name'
+require_relative 'types'
+require_relative 'values'
+
+module RubyVault
+  module Options
+    # rubocop:disable Metrics/ClassLength
+    class Definition < ImmutableStruct.new(
+      :name,
+      :option_type,
+      :value_type,
+      :override_keys,
+      :extra_keys,
+      :separator,
+      :placement,
+      :repeatable?
+    )
+      # rubocop:disable Metrics/MethodLength
+      def initialize(opts)
+        raise 'Missing name.' unless opts[:name]
+
+        super(
+          name: Name.new(opts[:name]),
+          option_type: Types.resolve(opts[:option_type]) || Types::Standard,
+          value_type: Values.resolve(opts[:value_type]) || Values::String,
+          repeatable: opts[:repeatable] || false,
+          separator: opts[:separator],
+          placement: opts[:placement],
+          extra_keys:
+            { singular: [], plural: [] }
+              .merge(opts[:extra_keys] || {}),
+          override_keys:
+            { singular: nil, plural: nil }
+              .merge(opts[:override_keys] || {})
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def matches?(name)
+        @name == Name.new(name)
+      end
+
+      def build(parameters)
+        build_singular_options(parameters) + build_plural_options(parameters)
+      end
+
+      private
+
+      def resolved_singular_key
+        if override_keys[:singular] == false
+          nil
+        else
+          override_keys[:singular] || name.as_singular_key
+        end
+      end
+
+      def all_singular_keys
+        ([resolved_singular_key] + extra_keys[:singular]).compact
+      end
+
+      def resolved_plural_key
+        if override_keys[:plural] == false
+          nil
+        else
+          override_keys[:plural] || name.as_plural_key
+        end
+      end
+
+      def all_plural_keys
+        ([resolved_plural_key] + extra_keys[:plural]).compact
+      end
+
+      def too_many_values?(values)
+        !repeatable? && values.length > 1
+      end
+
+      def values(parameters, keys)
+        keys.map { |k| parameters[k] }.compact
+      end
+
+      def needs_plural?(value)
+        repeatable? && !value.nil?
+      end
+
+      def only_singular?(value)
+        !needs_plural?(value)
+      end
+
+      def key_valued?(value)
+        value.respond_to?(:keys)
+      end
+
+      def multi_valued?(value)
+        value.respond_to?(:each)
+      end
+
+      def build_option(value)
+        option_type.new(name, value, separator: separator, placement: placement)
+      end
+
+      def build_value(value)
+        value_type.new(value)
+      end
+
+      def build_key_value(key, value)
+        Values::KeyValue.new(key, build_value(value))
+      end
+
+      def build_singular(value)
+        build_single_option(value)
+      end
+
+      def build_singulars(values)
+        values.map { |p| build_singular(p) }.flatten
+      end
+
+      def build_singular_options(parameters)
+        keys = all_singular_keys
+        values = values(parameters, keys)
+
+        if too_many_values?(values)
+          raise "Multiple values provided for '#{name}' " \
+                "(with keys #{keys}) and option not repeatable."
+        end
+
+        build_singulars(values)
+      end
+
+      def build_plural(value)
+        if only_singular?(value)
+          build_no_options
+        elsif key_valued?(value)
+          build_key_value_options(value)
+        elsif multi_valued?(value)
+          build_multiple_options(value)
+        else
+          build_single_option(value)
+        end
+      end
+
+      def build_plurals(values)
+        values.map { |p| build_plural(p) }.flatten
+      end
+
+      def build_plural_options(parameters)
+        keys = all_plural_keys
+        values = values(parameters, keys)
+
+        build_plurals(values)
+      end
+
+      def build_key_value_options(value)
+        value.map { |k, v| build_option(build_key_value(k, v)) }
+      end
+
+      def build_multiple_options(value)
+        value.map { |v| build_option(build_value(v)) }
+      end
+
+      def build_single_option(value)
+        [build_option(build_value(value))]
+      end
+
+      def build_no_options
+        []
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ruby_vault/options/definitions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyVault
+  module Options
+    DEFINITIONS = [
+      # string options
+      %w[
+        -method
+      ].map do |o|
+        definition(name: o, option_type: :standard, value_type: :string)
+      end
+    ].flatten.freeze
+  end
+end

data/lib/ruby_vault/options/factory.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'name'
+
+module RubyVault
+  module Options
+    class Factory
+      def initialize(definitions)
+        @definitions = definitions
+      end
+
+      def resolve(names, parameters)
+        names
+          .map { |name| Name.new(name) }
+          .inject([]) do |options, name|
+            options + resolve_name(name, parameters)
+          end
+      end
+
+      private
+
+      def resolve_name(name, parameters)
+        @definitions.find { |d| d.matches?(name) }.build(parameters)
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/name.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'immutable-struct'
+
+module RubyVault
+  module Options
+    class Name < ImmutableStruct.new(:name)
+      def initialize(name)
+        super(name: name.to_s)
+      end
+
+      def name
+        "-#{without_prefix}"
+      end
+
+      alias to_s name
+
+      def as_singular_key
+        snake_case.to_sym
+      end
+
+      def as_plural_key
+        "#{snake_case}s".to_sym
+      end
+
+      private
+
+      def without_prefix
+        @name.sub(/^-+/, '')
+      end
+
+      def snake_case
+        without_prefix.gsub('-', '_')
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/types/flag.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyVault
+  module Options
+    module Types
+      class Flag < ImmutableStruct.new(
+        :name,
+        :value
+      )
+        def initialize(name, value, **_opts)
+          super(name: name, value: value)
+        end
+
+        def apply(builder)
+          value.resolve ? builder.with_flag(name) : builder
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/types/standard.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyVault
+  module Options
+    module Types
+      class Standard < ImmutableStruct.new(
+        :name,
+        :value,
+        :separator,
+        :placement
+      )
+        def initialize(name, value, **opts)
+          super(
+            name: name, value: value,
+            separator: opts[:separator],
+            placement: opts[:placement]
+          )
+        end
+
+        def apply(builder)
+          builder.with_option(
+            name,
+            value.render,
+            separator: separator,
+            placement: placement
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/types.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'types/standard'
+require_relative 'types/flag'
+
+module RubyVault
+  module Options
+    module Types
+      def self.standard(name, value, **opts)
+        Standard.new(name, value, **opts)
+      end
+
+      def self.flag(name, value)
+        Flag.new(name, value)
+      end
+
+      def self.resolve(type)
+        case type
+        when :standard then Types::Standard
+        when :flag then Types::Flag
+        else type
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/values/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'immutable-struct'
+
+module RubyVault
+  module Options
+    module Values
+      class Base < ImmutableStruct.new(:value)
+        def initialize(value)
+          super(value: value)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/values/boolean.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RubyVault
+  module Options
+    module Values
+      class Boolean < Base
+        def resolve
+          return nil if @value.nil?
+          return @value if a_boolean?(@value)
+          return true if true_as_string?(@value)
+
+          false
+        end
+
+        def render
+          resolve.nil? ? nil : resolve.to_s
+        end
+
+        private
+
+        def a_boolean?(value)
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        end
+
+        def true_as_string?(value)
+          value.respond_to?(:downcase) && value.downcase == 'true'
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/values/complex.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'base'
+
+module RubyVault
+  module Options
+    module Values
+      class Complex < Base
+        def resolve
+          @value
+        end
+
+        def render
+          @value.is_a?(::String) ? @value : JSON.generate(value)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/values/key_value.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'immutable-struct'
+
+module RubyVault
+  module Options
+    module Values
+      class KeyValue < ImmutableStruct.new(:key, :value)
+        def initialize(key, value)
+          super(key: key, value: value)
+        end
+
+        def resolve
+          { key => value.resolve }
+        end
+
+        def render
+          "'#{key}=#{value.render}'"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/values/string.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RubyVault
+  module Options
+    module Values
+      class String < Base
+        def resolve
+          @value.to_s
+        end
+
+        alias render resolve
+      end
+    end
+  end
+end

data/lib/ruby_vault/options/values.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'values/boolean'
+require_relative 'values/string'
+require_relative 'values/complex'
+require_relative 'values/key_value'
+
+module RubyVault
+  module Options
+    module Values
+      def self.boolean(value)
+        Boolean.new(value)
+      end
+
+      def self.string(value)
+        String.new(value)
+      end
+
+      def self.complex(value)
+        Complex.new(value)
+      end
+
+      def self.key_value(key, value)
+        KeyValue.new(key, value)
+      end
+
+      def self.resolve(type)
+        case type
+        when :string then Values::String
+        when :boolean then Values::Boolean
+        when :complex then Values::Complex
+        when :key_value then Values::KeyValue
+        else type
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vault/options.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'options/name'
+require_relative 'options/types'
+require_relative 'options/values'
+require_relative 'options/definition'
+require_relative 'options/factory'
+
+module RubyVault
+  module Options
+    def self.name(name)
+      Name.new(name)
+    end
+
+    def self.definition(opts)
+      Definition.new(opts)
+    end
+
+    def self.types
+      Types
+    end
+
+    def self.values
+      Values
+    end
+  end
+end
+
+require_relative 'options/definitions'

data/lib/ruby_vault/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyVault
-  VERSION = '0.1.0.pre.2'
+  VERSION = '0.1.0.pre.5'
 end

data/lib/ruby_vault.rb

@@ -1,3 +1,69 @@
 # frozen_string_literal: true
 
-require 'ruby_vault/version'
+require_relative 'ruby_vault/options'
+require_relative 'ruby_vault/version'
+require_relative 'ruby_vault/commands'
+require 'logger'
+
+module RubyVault
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset!
+      @configuration = nil
+    end
+  end
+
+  module ClassMethods
+    def login(parameters = {}, invocation_options = {})
+      exec(RubyVault::Commands::Login,
+           parameters, invocation_options)
+    end
+
+    def write(parameters = {}, invocation_options = {})
+      exec(RubyVault::Commands::Write,
+           parameters, invocation_options)
+    end
+
+    private
+
+    def exec(command_class, parameters, invocation_options)
+      command_class.new.execute(parameters, invocation_options)
+    end
+  end
+
+  extend ClassMethods
+
+  def self.included(other)
+    other.extend(ClassMethods)
+  end
+
+  class Configuration
+    attr_accessor :binary, :logger, :options, :stdin, :stdout, :stderr
+
+    def default_logger
+      logger = Logger.new($stdout)
+      logger.level = Logger::INFO
+      logger
+    end
+
+    def default_options
+      Options::Factory.new(Options::DEFINITIONS)
+    end
+
+    def initialize
+      @binary = 'vault'
+      @logger = default_logger
+      @options = default_options
+      @stdin = ''
+      @stdout = $stdout
+      @stderr = $stderr
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_vault
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.2
+  version: 0.1.0.pre.5
 platform: ruby
 authors:
 - InfraBlocks Maintainers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-02 00:00:00.000000000 Z
+date: 2022-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: immutable-struct
@@ -279,6 +279,26 @@ files:
 - bin/console
 - bin/setup
 - lib/ruby_vault.rb
+- lib/ruby_vault/commands.rb
+- lib/ruby_vault/commands/base.rb
+- lib/ruby_vault/commands/login.rb
+- lib/ruby_vault/commands/write.rb
+- lib/ruby_vault/errors.rb
+- lib/ruby_vault/errors/execution_error.rb
+- lib/ruby_vault/options.rb
+- lib/ruby_vault/options/definition.rb
+- lib/ruby_vault/options/definitions.rb
+- lib/ruby_vault/options/factory.rb
+- lib/ruby_vault/options/name.rb
+- lib/ruby_vault/options/types.rb
+- lib/ruby_vault/options/types/flag.rb
+- lib/ruby_vault/options/types/standard.rb
+- lib/ruby_vault/options/values.rb
+- lib/ruby_vault/options/values/base.rb
+- lib/ruby_vault/options/values/boolean.rb
+- lib/ruby_vault/options/values/complex.rb
+- lib/ruby_vault/options/values/key_value.rb
+- lib/ruby_vault/options/values/string.rb
 - lib/ruby_vault/version.rb
 - ruby_vault.gemspec
 homepage: https://github.com/infrablocks/ruby_vault