ruby_npm 0.1.0.pre.1

data/lib/ruby_npm/commands/install.rb

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

data/lib/ruby_npm/commands.rb

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

data/lib/ruby_npm/errors/execution_error.rb

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

data/lib/ruby_npm/errors.rb

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

data/lib/ruby_npm/options/definition.rb

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

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

data/lib/ruby_npm/options/factory.rb

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

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

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

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

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

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

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

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

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

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

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

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

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

data/lib/ruby_npm/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 RubyNPM
+  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_npm/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 RubyNPM
+  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_npm/version.rb

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

data/lib/ruby_npm.rb

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

data/ruby_npm.gemspec

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_npm/version'
+require 'date'
+
+files = %w[
+  bin
+  lib
+  CODE_OF_CONDUCT.md
+  ruby_npm.gemspec
+  Gemfile
+  LICENSE.txt
+  Rakefile
+  README.md
+]
+
+Gem::Specification.new do |spec|
+  spec.name = 'ruby_npm'
+  spec.version = RubyNPM::VERSION
+  spec.authors = ['InfraBlocks Maintainers']
+  spec.email = ['maintainers@infrablocks.io']
+
+  spec.summary = 'A simple Ruby wrapper for invoking NPM commands.'
+  spec.description =
+    'Wraps the NPM CLI so that NPM can be invoked from a Ruby ' \
+    'script or Rakefile.'
+  spec.homepage = 'https://github.com/infrablocks/ruby_npm'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").select do |f|
+    f.match(/^(#{files.map { |g| Regexp.escape(g) }.join('|')})/)
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.7'
+
+  spec.add_dependency 'immutable-struct', '~> 2.4'
+  spec.add_dependency 'lino', '~> 3.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'faker'
+  spec.add_development_dependency 'gem-release'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake_circle_ci'
+  spec.add_development_dependency 'rake_github'
+  spec.add_development_dependency 'rake_gpg'
+  spec.add_development_dependency 'rake_ssh'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'terminal-notifier-guard'
+  spec.add_development_dependency 'yard'
+
+  spec.metadata['rubygems_mfa_required'] = 'false'
+end