ruby_git_crypt 0.1.0.pre.1

data/lib/ruby_git_crypt/commands/status.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RubyGitCrypt
+  module Commands
+    class Status < Base
+      # @!visibility private
+      def subcommands
+        %w[status]
+      end
+    end
+  end
+end

data/lib/ruby_git_crypt/commands.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'commands/status'
+
+module RubyGitCrypt
+  module Commands
+  end
+end

data/lib/ruby_git_crypt/errors/execution_error.rb

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

data/lib/ruby_git_crypt/errors.rb

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

data/lib/ruby_git_crypt/options/definition.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'immutable-struct'
+
+require_relative './name'
+require_relative './types'
+require_relative './values'
+
+module RubyGitCrypt
+  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_git_crypt/options/definitions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyGitCrypt
+  module Options
+    DEFINITIONS = [].freeze
+  end
+end

data/lib/ruby_git_crypt/options/factory.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'name'
+
+module RubyGitCrypt
+  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_git_crypt/options/name.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'immutable-struct'
+
+module RubyGitCrypt
+  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_git_crypt/options/sets.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RubyGitCrypt
+  module Options
+    module Sets
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyGitCrypt
+  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_git_crypt/options/types/standard.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyGitCrypt
+  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_git_crypt/options/types.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'types/standard'
+require_relative 'types/flag'
+
+module RubyGitCrypt
+  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_git_crypt/options/values/base.rb

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

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RubyGitCrypt
+  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&.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_git_crypt/options/values/complex.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'base'
+
+module RubyGitCrypt
+  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_git_crypt/options/values/key_value.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'immutable-struct'
+
+module RubyGitCrypt
+  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_git_crypt/options/values/string.rb

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

data/lib/ruby_git_crypt/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 RubyGitCrypt
+  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_git_crypt/options.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'options/name'
+require_relative 'options/types'
+require_relative 'options/values'
+require_relative 'options/definition'
+require_relative 'options/factory'
+require_relative 'options/sets'
+
+module RubyGitCrypt
+  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_git_crypt/version.rb

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

data/lib/ruby_git_crypt.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'ruby_git_crypt/options'
+require_relative 'ruby_git_crypt/version'
+require_relative 'ruby_git_crypt/commands'
+require 'logger'
+
+module RubyGitCrypt
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset!
+      @configuration = nil
+    end
+  end
+
+  module ClassMethods
+    def status(parameters = {}, invocation_options = {})
+      exec(RubyGitCrypt::Commands::Status,
+           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 = 'git-crypt'
+      @logger = default_logger
+      @options = default_options
+      @stdin = ''
+      @stdout = $stdout
+      @stderr = $stderr
+    end
+  end
+end