ruby_vault 0.1.0.pre.3 → 0.1.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19e8aadca9a6285c7decb702603d6a0ef61aa6b644a46c236ac96ce3ad9a6310
-  data.tar.gz: 8bff21c678170fb4187d171c859756cec283e3d546d0b1ae3a02248f76d6393a
+  metadata.gz: 4acec404ddce5a052368e45f94bfc2680d6abe076f791a595b5a4a0c912daa75
+  data.tar.gz: 597d76b4adab3af5e998f16d83e43f0a9d103f9d85a12b00de6f63a1b8c82487
 SHA512:
-  metadata.gz: 81c23a4e58bb4954f769c3dda63196fa7af0b06736cbf79f566cd1b88555eb31a55f2635a3d8961067d265bc8245350bb8e4f513d5a3479d6d4c3aa8439fd74b
-  data.tar.gz: 209e56bdf568f52332287e19c9190694995482a35c1fa5c79186f81e3fe920edad50cbd2bbdf2bd4499f7c9c1417b9e805f1e99495e4307665daa35c8203be2e
+  metadata.gz: b4e537621c4d2a78bf36117e68c729529cb0bb156a8761acc9ee417a7978ed01e1895772badc3c6b8b76afbcf5aac57b7837763480e002acb4f176ce6ee37f19
+  data.tar.gz: 28a4fe8456d6e1ac25e5e9bc3bb00971739e17a06a1caf167f521a233fc171e7c8a303186a9ab56c88dc494f8e160bdd4577495f24eaf472d962471d774846e5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby_vault (0.1.0.pre.3)
+    ruby_vault (0.1.0.pre.4)
       immutable-struct (~> 2.4)
       lino (~> 3.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.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'commands/login'
+
+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

@@ -2,6 +2,13 @@
 
 module RubyVault
   module Options
-    DEFINITIONS = [].freeze
+    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/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

@@ -1,9 +1,28 @@
 # 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
 

data/lib/ruby_vault/version.rb

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

data/lib/ruby_vault.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'ruby_vault/options'
-require 'ruby_vault/version'
+require_relative 'ruby_vault/options'
+require_relative 'ruby_vault/version'
+require_relative 'ruby_vault/commands'
 require 'logger'
 
 module RubyVault
@@ -10,11 +11,34 @@ module RubyVault
       @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
+
+    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
 
@@ -29,7 +53,7 @@ module RubyVault
     end
 
     def initialize
-      @binary = 'terraform'
+      @binary = 'vault'
       @logger = default_logger
       @options = default_options
       @stdin = ''

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_vault
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.3
+  version: 0.1.0.pre.4
 platform: ruby
 authors:
 - InfraBlocks Maintainers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-03 00:00:00.000000000 Z
+date: 2022-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: immutable-struct
@@ -279,10 +279,25 @@ 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/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