ruby_fly 0.38.0.pre.2 → 0.38.0.pre.4

data/lib/ruby_fly/commands/mixins/required_params.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyFly
+  module Commands
+    module Mixins
+      module RequiredParams
+        def configure_command(builder, opts)
+          assert_required_params(opts)
+          super(builder, opts)
+        end
+
+        def required_params
+          %i[]
+        end
+
+        private
+
+        def missing_params(opts)
+          required_params.select { |param| opts[param].nil? }
+        end
+
+        def assert_required_params(opts)
+          missing_params = missing_params(opts)
+          return if missing_params.empty?
+
+          description = missing_params.map { |p| "'#{p}'" }.join(', ')
+          raise(
+            ArgumentError,
+            "Error: #{description} required but not provided."
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_fly/commands/set_pipeline.rb

@@ -1,52 +1,80 @@
+# frozen_string_literal: true
+
 require 'lino'
 require_relative 'base'
 require_relative 'mixins/environment'
+require_relative 'mixins/required_params'
 
 module RubyFly
   module Commands
     class SetPipeline < Base
       include Mixins::Environment
+      include Mixins::RequiredParams
 
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
       def configure_command(builder, opts)
         builder = super(builder, opts)
-
-        missing_params = [
-            :target,
-            :pipeline,
-            :config
-        ].select { |param| opts[param].nil? }
-
-        unless missing_params.empty?
-          description = missing_params.map { |p| "'#{p}'" }.join(', ')
-          raise(
-              ArgumentError,
-              "Error: #{description} required but not provided.")
-        end
-
-        target = opts[:target]
-        pipeline = opts[:pipeline]
-        config = opts[:config]
-        vars = opts[:vars] || {}
-        var_files = opts[:var_files] || []
-        non_interactive = opts[:non_interactive]
-        team = opts[:team]
-
         builder
           .with_subcommand('set-pipeline') do |sub|
-            sub = sub.with_option('-t', target)
-            sub = sub.with_option('-p', pipeline)
-            sub = sub.with_option('-c', config)
-            sub = sub.with_option('--team', team) if team
-            vars.each do |key, value|
-              sub = sub.with_option('-v', "'#{key}=#{value}'")
-            end
-            var_files.each do |var_file|
-              sub = sub.with_option('-l', var_file)
-            end
-            sub = sub.with_flag('-n') if non_interactive
+            sub = with_target(sub, opts[:target])
+            sub = with_pipeline(sub, opts[:pipeline])
+            sub = with_config(sub, opts[:config])
+            sub = with_team(sub, opts[:team])
+            sub = with_vars(sub, opts[:vars])
+            sub = with_var_files(sub, opts[:var_files])
+            sub = with_non_interactive(sub, opts[:non_interactive])
             sub
           end
       end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def required_params
+        %i[target pipeline config]
+      end
+
+      def with_target(sub, target)
+        sub.with_option('-t', target)
+      end
+
+      def with_pipeline(sub, pipeline)
+        sub.with_option('-p', pipeline)
+      end
+
+      def with_config(sub, config)
+        sub.with_option('-c', config)
+      end
+
+      def with_team(sub, team)
+        return sub unless team
+
+        sub.with_option('--team', team)
+      end
+
+      def with_vars(builder, vars)
+        vars ||= {}
+        vars.each do |key, value|
+          builder = builder.with_option('-v', "'#{key}=#{value}'")
+        end
+        builder
+      end
+
+      def with_var_files(builder, var_files)
+        var_files ||= []
+        var_files.each do |var_file|
+          builder = builder.with_option('-l', var_file)
+        end
+        builder
+      end
+
+      def with_non_interactive(builder, non_interactive)
+        return builder unless non_interactive
+
+        builder.with_flag('-n')
+      end
     end
   end
-end
+end

data/lib/ruby_fly/commands/status.rb

@@ -1,52 +1,40 @@
+# frozen_string_literal: true
+
 require 'lino'
 require_relative 'base'
 require_relative 'mixins/environment'
+require_relative 'mixins/required_params'
 
 module RubyFly
   module Commands
     class Status < Base
       include Mixins::Environment
+      include Mixins::RequiredParams
 
       def initialize(*args)
         super(*args)
         @stdout = StringIO.new unless
-            (defined?(@stdout) && @stdout.respond_to?(:string))
+            defined?(@stdout) && @stdout.respond_to?(:string)
         @stderr = StringIO.new unless
-            (defined?(@stderr) && @stderr.respond_to?(:string))
+            defined?(@stderr) && @stderr.respond_to?(:string)
       end
 
       def configure_command(builder, opts)
         builder = super(builder, opts)
-
-        missing_params = [
-            :target
-        ].select { |param| opts[param].nil? }
-
-        unless missing_params.empty?
-          description = missing_params.map { |p| "'#{p}'" }.join(', ')
-          raise(
-              ArgumentError,
-              "Error: #{description} required but not provided.")
-        end
-
-        target = opts[:target]
-
         builder
           .with_subcommand('status') do |sub|
-            sub = sub.with_option('-t', target)
+            sub = with_target(sub, opts[:target])
             sub
           end
       end
 
       def do_around(opts, &block)
-        begin
-          block.call(opts)
-        rescue Open4::SpawnError => e
-          raise e unless e.status.exitstatus == 1
-        end
+        block.call(opts)
+      rescue Open4::SpawnError => e
+        raise e unless e.status.exitstatus == 1
       end
 
-      def do_after(opts)
+      def do_after(_opts)
         output = stdout.string
         error = stderr.string
 
@@ -57,6 +45,16 @@ module RubyFly
 
         :unknown_status
       end
+
+      private
+
+      def required_params
+        %i[target]
+      end
+
+      def with_target(sub, target)
+        sub.with_option('-t', target)
+      end
     end
   end
-end
+end

data/lib/ruby_fly/commands/unpause_pipeline.rb

@@ -1,39 +1,46 @@
+# frozen_string_literal: true
+
 require 'lino'
 require_relative 'base'
 require_relative 'mixins/environment'
+require_relative 'mixins/required_params'
 
 module RubyFly
   module Commands
     class UnpausePipeline < Base
       include Mixins::Environment
+      include Mixins::RequiredParams
 
       def configure_command(builder, opts)
         builder = super(builder, opts)
+        builder
+          .with_subcommand('unpause-pipeline') do |sub|
+          sub = with_target(sub, opts[:target])
+          sub = with_pipeline(sub, opts[:pipeline])
+          sub = with_team(sub, opts[:team])
+          sub
+        end
+      end
 
-        missing_params = [
-            :target,
-            :pipeline
-        ].select { |param| opts[param].nil? }
+      private
 
-        unless missing_params.empty?
-          description = missing_params.map { |p| "'#{p}'" }.join(', ')
-          raise(
-              ArgumentError,
-              "Error: #{description} required but not provided.")
-        end
+      def required_params
+        %i[target pipeline]
+      end
 
-        target = opts[:target]
-        pipeline = opts[:pipeline]
-        team = opts[:team]
+      def with_target(sub, target)
+        sub.with_option('-t', target)
+      end
 
-        builder
-            .with_subcommand('unpause-pipeline') do |sub|
-              sub = sub.with_option('-t', target)
-              sub = sub.with_option('-p', pipeline)
-              sub = sub.with_option('--team', team) if team
-              sub
-            end
+      def with_pipeline(sub, pipeline)
+        sub.with_option('-p', pipeline)
+      end
+
+      def with_team(sub, team)
+        return sub unless team
+
+        sub.with_option('--team', team)
       end
     end
   end
-end
+end

data/lib/ruby_fly/commands/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'lino'
 require_relative 'base'
 
@@ -8,15 +10,15 @@ module RubyFly
         @version_string
       end
 
-      def do_before(opts)
+      def do_before(_opts)
         @version_string = StringIO.new
       end
 
-      def configure_command(builder, opts)
+      def configure_command(builder, _opts)
         builder.with_flag('--version')
       end
 
-      def do_after(opts)
+      def do_after(_opts)
         @version_string.string.gsub(/\n/, '')
       end
     end

data/lib/ruby_fly/commands.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'commands/login'
 require_relative 'commands/status'
 require_relative 'commands/get_pipeline'
@@ -9,4 +11,4 @@ require_relative 'commands/version'
 module RubyFly
   module Commands
   end
-end
+end

data/lib/ruby_fly/rc.rb

@@ -1,44 +1,24 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 
 module RubyFly
   class RC
     module Conversions
       def self.symbolize_keys(hash)
-        hash.inject({}) { |result, (key, value)|
-          new_key = case key
-          when String then
-            key.to_sym
-          else
-            key
-          end
-          new_value = case value
-          when Hash then
-            symbolize_keys(value)
-          else
-            value
-          end
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.is_a?(String) ? key.to_sym : key
+          new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
           result[new_key] = new_value
-          result
-        }
+        end
       end
 
       def self.stringify_keys(hash)
-        hash.inject({}) { |result, (key, value)|
-          new_key = case key
-          when Symbol then
-            key.to_s
-          else
-            key
-          end
-          new_value = case value
-          when Hash then
-            stringify_keys(value)
-          else
-            value
-          end
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.is_a?(Symbol) ? key.to_s : key
+          new_value = value.is_a?(Hash) ? stringify_keys(value) : value
           result[new_key] = new_value
-          result
-        }
+        end
       end
     end
 
@@ -55,18 +35,18 @@ module RubyFly
     end
 
     class Target
-      attr_reader :name, :api, :team, :token
-      attr_writer :api, :team, :token
+      attr_accessor :api, :team, :token
+      attr_reader :name
 
       def self.clone(target, overrides = {})
-        if target.nil?
-          return target
-        end
+        return target if target.nil?
+
         Target.new(
-            name: overrides[:name] || target.name,
-            api: overrides[:api] || target.api,
-            team: overrides[:team] || target.team,
-            token: overrides[:token] || target.token)
+          name: overrides[:name] || target.name,
+          api: overrides[:api] || target.api,
+          team: overrides[:team] || target.team,
+          token: overrides[:token] || target.token
+        )
       end
 
       def initialize(parameters)
@@ -78,25 +58,22 @@ module RubyFly
 
       def bearer_token=(value)
         @token = {
-            type: 'bearer',
-            value: value
+          type: 'bearer',
+          value: value
         }
       end
 
       def bearer_token
-        @token[:type] == 'bearer' ?
-            @token[:value] :
-            nil
+        @token[:value] if @token[:type] == 'bearer'
       end
 
       def encode_with(coder)
         coder.represent_map(
-            nil,
-            RubyFly::RC::Conversions.stringify_keys({
-                api: @api,
-                team: @team.to_s,
-                token: @token
-            }))
+          nil,
+          RubyFly::RC::Conversions.stringify_keys(
+            { api: @api, team: @team.to_s, token: @token }
+          )
+        )
       end
 
       def ==(other)
@@ -119,26 +96,38 @@ module RubyFly
     end
 
     def self.load(options)
-      home = options[:home] || ENV['HOME']
+      home = options[:home] || Dir.home
       name = options[:name] || '.flyrc'
       path = File.join(home, name)
 
-      contents = options[:contents] ||
-          (File.exist?(path) ?
-              RubyFly::RC::Conversions.symbolize_keys(YAML.load_file(path)) :
-              {})
-      targets = File.exist?(path) ?
-          contents[:targets].map { |n, t| Target.new(t.merge(name: n)) } :
-          []
+      contents = options[:contents] || try_load_rc_file_contents(path) || {}
+      targets = try_load_rc_file_targets(path, contents) || []
+
+      RubyFly::RC.new(home: home, name: name, targets: targets)
+    end
+
+    class << self
+      private
+
+      def rc_file_exists?(path)
+        File.exist?(path)
+      end
+
+      def try_load_rc_file_contents(path)
+        return unless rc_file_exists?(path)
+
+        RubyFly::RC::Conversions.symbolize_keys(YAML.load_file(path))
+      end
+
+      def try_load_rc_file_targets(path, contents)
+        return unless rc_file_exists?(path)
 
-      RubyFly::RC.new(
-          home: home,
-          name: name,
-          targets: targets)
+        contents[:targets].map { |n, t| Target.new(t.merge(name: n)) }
+      end
     end
 
     def initialize(options)
-      @home = options[:home] || ENV['HOME']
+      @home = options[:home] || Dir.home
       @name = options[:name] || '.flyrc'
       @targets = options[:targets].inject({}) do |acc, target|
         acc.merge(target.name => target)
@@ -149,25 +138,23 @@ module RubyFly
       @targets.values
     end
 
-    def find_target(target_name)
-      Target.clone(@targets[target_name.to_sym])
+    def target?(target_name)
+      @targets.key?(target_name)
     end
 
-    def has_target?(target_name)
-      @targets.has_key?(target_name)
+    def find_target(target_name)
+      Target.clone(@targets[target_name.to_sym])
     end
 
     def add_target(target)
-      if has_target?(target.name)
-        raise TargetAlreadyPresentError.new(target.name)
-      end
+      raise TargetAlreadyPresentError, target.name if target?(target.name)
+
       @targets[target.name] = target
     end
 
     def update_target(target_name, &block)
-      unless has_target?(target_name)
-        raise TargetNotPresentError.new(target_name)
-      end
+      raise TargetNotPresentError, target_name unless target?(target_name)
+
       mutable_target = find_target(target_name)
       block.call(mutable_target)
       updated_target = Target.clone(mutable_target, name: target_name)
@@ -175,9 +162,11 @@ module RubyFly
     end
 
     def add_or_update_target(target_name, &block)
-      mutable_target = has_target?(target_name) ?
-          find_target(target_name) :
-          Target.new({name: target_name})
+      mutable_target = if target?(target_name)
+                         find_target(target_name)
+                       else
+                         Target.new({ name: target_name })
+                       end
       block.call(mutable_target)
       updated_target = Target.clone(mutable_target, name: target_name)
       @targets[target_name] = updated_target
@@ -191,23 +180,20 @@ module RubyFly
     end
 
     def remove_target(target_name)
-      unless has_target?(target_name)
-        raise TargetNotPresentError.new(target_name)
-      end
+      raise TargetNotPresentError, target_name unless target?(target_name)
+
       @targets.delete(target_name)
     end
 
     def to_yaml
       RubyFly::RC::Conversions
-          .stringify_keys({targets: @targets})
-          .to_yaml
+        .stringify_keys({ targets: @targets })
+        .to_yaml
     end
 
     def write!
       FileUtils.mkdir_p(@home)
-      File.open(File.join(@home, @name), 'w') do |file|
-        file.write(to_yaml)
-      end
+      File.write(File.join(@home, @name), to_yaml)
     end
   end
-end
+end

data/lib/ruby_fly/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RubyFly
-  VERSION = '0.38.0.pre.2'
+  VERSION = '0.38.0.pre.4'
 end

data/lib/ruby_fly.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ruby_fly/version'
 require 'ruby_fly/commands'
 require 'ruby_fly/rc'

data/ruby_fly.gemspec

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_fly/version'
+
+files = %w[
+  bin
+  lib
+  CODE_OF_CONDUCT.md
+  ruby_fly.gemspec
+  Gemfile
+  LICENSE.txt
+  Rakefile
+  README.md
+]
+
+Gem::Specification.new do |spec|
+  spec.name = 'ruby_fly'
+  spec.version = RubyFly::VERSION
+  spec.authors = ['InfraBlocks Maintainers']
+  spec.email = ['maintainers@infrablocks.io']
+
+  spec.summary = 'A simple Ruby wrapper for invoking fly commands.'
+  spec.description = 'Wraps the concourse fly CLI so that fly can be invoked ' \
+                     'from a Ruby script or Rakefile.'
+  spec.homepage = 'https://github.com/infrablocks/ruby_fly'
+  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 'lino', '~> 3.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'fakefs'
+  spec.add_development_dependency 'faker'
+  spec.add_development_dependency 'gem-release'
+  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.metadata['rubygems_mfa_required'] = 'false'
+end