firespring_dev_commands 1.3.0

data/lib/firespring_dev_commands/templates/docker/default.rb

@@ -0,0 +1,200 @@
+require_relative '../base_interface'
+
+module Dev
+  module Template
+    # Module containing all default docker rake tasks
+    module Docker
+      # Class containing default rake tasks which are application agnostic (run against all containers)
+      class Default < Dev::Template::BaseInterface
+        # Create the rake task which runs a docker compose build
+        def create_build_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:build)
+
+            desc 'Builds all images used by services in the compose files' \
+                 "\n\toptionally specify NO_CACHE=true to not use build cache" \
+                 "\n\toptionally specify PULL=true to force pulling new base images"
+            task build: %w(init_docker) do
+              LOG.debug('In base build')
+              Dev::Docker::Compose.new.build
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose up
+        def create_up_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:up)
+
+            desc 'Starts containers for all services listed in the compose files' \
+                 "\n\toptionally specify DETACHED=false to not detach from the started services"
+            task up: %w(init_docker) do
+              LOG.debug('In base up')
+              Dev::Docker::Compose.new.up
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose logs
+        def create_logs_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:logs)
+
+            desc 'Connects to the output stream of all running containers' \
+                 "\n\toptionally specify NO_FOLLOW=true to print all current output and exit" \
+                 "\n\toptionally specify TAIL=n to print the last 'n' lines of output"
+            task logs: %w(init_docker) do
+              LOG.debug('In base logs')
+              Dev::Docker::Compose.new.logs
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose down
+        def create_down_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:down)
+
+            desc 'Stops and removes containers and associated resources' \
+                 "\n\toptionally specify REMOVE_VOLUMES=true to also remove unused volumes"
+            task down: %w(init_docker) do
+              LOG.debug('In base down')
+              Dev::Docker::Compose.new.down
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose down followed by an up
+        def create_reload_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:reload)
+
+            desc 'Runs a "down" followed by an "up"'
+            task reload: %w(down up) do
+              LOG.debug('In reload')
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose clean
+        def create_clean_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:clean)
+
+            desc 'Removes all stopped containers and unused images, volumes, and networks'
+            task clean: %w(init_docker) do
+              LOG.debug 'In base clean'
+              Dev::Docker.new.prune
+              LOG.info
+            end
+            task prune: [:clean] do
+              # This is an alias to the clean command
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose push
+        def create_push_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:push)
+
+            desc 'Push all local images to their defined image repository'
+            task push: %w(init_docker) do
+              LOG.debug 'In base push'
+              Dev::Docker::Compose.new.push
+            end
+          end
+        end
+
+        # Create the rake task which runs a docker compose pull
+        def create_pull_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:pull)
+
+            desc 'Pull all images from their defined image repository'
+            task pull: %w(init_docker) do
+              LOG.debug 'In base pull'
+              Dev::Docker::Compose.new.pull
+            end
+          end
+        end
+
+        # Create the rake task which shows all docker images on the system
+        def create_images_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:images)
+
+            desc 'Print a table of all images' \
+                 "\n\t(equivalent to docker images)"
+            task images: %w(init_docker) do
+              Dev::Docker.new.print_images
+            end
+          end
+        end
+
+        # Create the rake task which shows all docker containers on the system
+        def create_ps_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            return if exclude.include?(:ps)
+
+            desc 'Print a table of all running containers' \
+                 "\n\t(equivalent to docker ps)"
+            task ps: %w(init_docker) do
+              Dev::Docker.new.print_containers
+            end
+          end
+        end
+
+        # Create the rake task which shows all docker images on the system
+        def create_images_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            unless exclude.include?(:images)
+              desc 'Print a table of all images' \
+                   "\n\t(equivalent to docker images)"
+              task images: [:init] do
+                Dev::Docker.new.print_images
+              end
+            end
+          end
+        end
+
+        # Create the rake task which shows all docker containers on the system
+        def create_ps_task!
+          exclude = @exclude
+
+          DEV_COMMANDS_TOP_LEVEL.instance_eval do
+            unless exclude.include?(:ps)
+              desc 'Print a table of all running containers' \
+                   "\n\t(equivalent to docker ps)"
+              task ps: [:init] do
+                Dev::Docker.new.print_containers
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/templates/docker/node/application.rb

@@ -0,0 +1,145 @@
+require_relative '../../base_interface'
+
+module Dev
+  module Template
+    module Docker
+      # Module for rake tasks associated with node applications
+      module Node
+        # Class for default rake tasks associated with a node project
+        class Application < Dev::Template::ApplicationInterface
+          # Allow for custom container path for the application
+          def initialize(application, container_path: nil, local_path: nil, exclude: [])
+            @node = Dev::Node.new(container_path: container_path, local_path: local_path)
+            super(application, exclude: exclude)
+          end
+
+          # Create the rake task which runs linting for the application name
+          def create_lint_task!
+            application = @name
+            node = @node
+            exclude = @exclude
+            return if exclude.include?(:lint)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all linting software'
+                task lint: %w(node:lint) do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :node do
+                  desc "Run the node linting software against the #{application}'s codebase"
+                  task lint: %w(init_docker up_no_deps) do
+                    LOG.debug('Check for node linting errors')
+
+                    options = []
+                    options << '-T' if Dev::Common.new.running_codebuild?
+                    Dev::Docker::Compose.new(services: application, options: options).exec(*node.lint_command)
+                  end
+
+                  namespace :lint do
+                    desc "Run the linting software against the #{application}'s codebase and apply all available fixes"
+                    task fix: %w(init_docker up_no_deps) do
+                      LOG.debug('Check and fix linting errors')
+
+                      options = []
+                      options << '-T' if Dev::Common.new.running_codebuild?
+                      Dev::Docker::Compose.new(services: application, options: options).exec(*node.lint_fix_command)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake task which runs all tests for the application name
+          def create_test_task!
+            application = @name
+            node = @node
+            exclude = @exclude
+            return if exclude.include?(:test)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all tests'
+                task test: %w(node:test) do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :node do
+                  desc "Run all node tests against the #{application}'s codebase"
+                  task test: %w(init_docker up) do
+                    LOG.debug("Running all node tests in the #{application} codebase")
+
+                    options = []
+                    options << '-T' if Dev::Common.new.running_codebuild?
+                    Dev::Docker::Compose.new(services: application, options: options).exec(*node.test_command)
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake task which runs the install command for the application packages
+          def create_install_task!
+            # Have to set a local variable to be accessible inside of the instance_eval block
+            application = @name
+            node = @node
+            exclude = @exclude
+            return if exclude.include?(:install)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                namespace :node do
+                  desc 'Install all npm packages'
+                  task install: %w(init_docker up_no_deps) do
+                    Dev::Docker::Compose.new(services: application).exec(*node.install_command)
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake tasks which runs the security audits of application packages
+          def create_audit_task!
+            # Have to set a local variable to be accessible inside of the instance_eval block
+            application = @name
+            node = @node
+            exclude = @exclude
+            return if exclude.include?(:audit)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all security audits'
+                task audit: %w(node:audit) do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :node do
+                  desc 'Run NPM Audit on the target application' \
+                       "\n\tuse MIN_SEVERITY=(info low moderate high critical) to fetch only severity type selected and above (default=high)." \
+                       "\n\tuse IGNORELIST=(comma delimited list of ids) removes the entry from the list."
+                  task audit: %w(init_docker up_no_deps) do
+                    opts = []
+                    opts << '-T' if Dev::Common.new.running_codebuild?
+
+                    # Retrieve results of the scan.
+                    data = Dev::Docker::Compose.new(services: application, options: opts, capture: true).exec(*node.audit_command)
+                    Dev::Node::Audit.new(data).to_report.check
+                  end
+
+                  namespace :audit do
+                    desc 'Run NPM Audit fix command'
+                    task fix: %w(init_docker up_no_deps) do
+                      Dev::Docker::Compose.new(services: application).exec(*node.audit_fix_command)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/templates/docker/php/application.rb

@@ -0,0 +1,190 @@
+require_relative '../../base_interface'
+
+module Dev
+  module Template
+    module Docker
+      # Module for rake tasks associated with php applications
+      module Php
+        # Class for default rake tasks associated with a php project
+        class Application < Dev::Template::ApplicationInterface
+          # Allow for custom container path for the application
+          def initialize(application, container_path: nil, local_path: nil, exclude: [])
+            @php = Dev::Php.new(container_path: container_path, local_path: local_path)
+            super(application, exclude: exclude)
+          end
+
+          # Create the rake task which downloads the vendor directory to your local system for the given application name
+          def create_vendor_download_task!
+            application = @name
+            php = @php
+            exclude = @exclude
+            return if exclude.include?(:'vendor:download')
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                namespace :php do
+                  namespace :vendor do
+                    desc "Copy #{application} vendor files from the container to your local system"
+                    task download: %w(init_docker up_no_deps) do
+                      container = Dev::Docker::Compose.new.container_by_name(application)
+                      Dev::Docker.new.copy_from_container(container, "#{php.container_path}/vendor/", "#{php.local_path}/vendor/", required: true)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake task which uploads the vendor directory from your local system for the given application name
+          def create_vendor_upload_task!
+            application = @name
+            php = @php
+            exclude = @exclude
+            return if exclude.include?(:'vendor:upload')
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                namespace :php do
+                  namespace :vendor do
+                    desc "Copy #{application} vendor files from your local system to the container"
+                    task upload: %w(init_docker up_no_deps) do
+                      container = Dev::Docker::Compose.new.container_by_name(application)
+                      Dev::Docker.new.copy_to_container(container, "#{php.local_path}/vendor/", "#{php.container_path}/vendor/")
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake task which runs linting for the application name
+          def create_lint_task!
+            application = @name
+            php = @php
+            exclude = @exclude
+            return if exclude.include?(:lint)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all linting software'
+                task lint: %w(php:lint) do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :php do
+                  desc "Run the php linting software against the #{application}'s codebase"
+                  task lint: %w(init_docker up_no_deps) do
+                    LOG.debug("Check for php linting errors in the #{application} codebase")
+
+                    options = []
+                    options << '-T' if Dev::Common.new.running_codebuild?
+                    Dev::Docker::Compose.new(services: application, options: options).exec(*php.lint_command)
+                  end
+
+                  namespace :lint do
+                    desc "Run the php linting software against the #{application}'s codebase and apply all available fixes"
+                    task fix: %w(init_docker up_no_deps) do
+                      LOG.debug("Check and fix all php linting errors in the #{application} codebase")
+
+                      options = []
+                      options << '-T' if Dev::Common.new.running_codebuild?
+                      Dev::Docker::Compose.new(services: application, options: options).exec(*php.lint_fix_command)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake task which runs all tests for the application name
+          def create_test_task!
+            application = @name
+            php = @php
+            exclude = @exclude
+            return if exclude.include?(:test)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all tests'
+                task test: %w(php:test) do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :php do
+                  desc "Run all php tests against the #{application}'s codebase"
+                  task test: %w(init_docker up) do
+                    LOG.debug("Running all php tests in the #{application} codebase")
+
+                    options = []
+                    options << '-T' if Dev::Common.new.running_codebuild?
+                    Dev::Docker::Compose.new(services: application, options: options).exec(*php.test_command)
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake tasks which runs the install command for the application packages
+          def create_install_task!
+            # Have to set a local variable to be accessible inside of the instance_eval block
+            application = @name
+            php = @php
+            exclude = @exclude
+            return if exclude.include?(:install)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                namespace :php do
+                  desc 'Install all npm packages'
+                  task install: %w(init_docker up_no_deps) do
+                    Dev::Docker::Compose.new(services: application).exec(*php.install_command)
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake tasks which runs the security audits for the application packages
+          def create_audit_task!
+            # Have to set a local variable to be accessible inside of the instance_eval block
+            application = @name
+            php = @php
+            exclude = @exclude
+            return if exclude.include?(:audit)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all security audits'
+                task audit: %w(php:audit) do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :php do
+                  desc 'Run Composer Audit on the target application' \
+                       "\n\tuse MIN_SEVERITY=(info low moderate high critical) to fetch only severity type selected and above (default=high)." \
+                       "\n\tuse IGNORELIST=(comma delimited list of cwe numbers) removes the entry from the list."
+                  task audit: %w(init_docker up_no_deps) do
+                    opts = []
+                    opts << '-T' if Dev::Common.new.running_codebuild?
+
+                    # Retrieve results of the scan.
+                    data = Dev::Docker::Compose.new(services: application, options: opts, capture: true).exec(*php.audit_command)
+                    Dev::Php::Audit.new(data).to_report.check
+                  end
+
+                  # namespace :audit do
+                  #   desc 'Fix the composer vulnerabilities that were found'
+                  #   task fix: %w(init_docker up_no_deps) do
+                  #     raise 'not implemented'
+                  #     # Dev::Docker::Compose.new(services: application).exec(*php.audit_fix_command)
+                  #   end
+                  # end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/firespring_dev_commands/templates/docker/ruby/application.rb

@@ -0,0 +1,146 @@
+require_relative '../../base_interface'
+
+module Dev
+  module Template
+    module Docker
+      # Module for rake tasks associated with ruby applications
+      module Ruby
+        # Class for default rake tasks associated with a ruby project
+        class Application < Dev::Template::ApplicationInterface
+          # Allow for custom container path for the application
+          def initialize(application, container_path: nil, local_path: nil, exclude: [])
+            @ruby = Dev::Ruby.new(container_path: container_path, local_path: local_path)
+            super(application, exclude: exclude)
+          end
+
+          # Create the rake task which runs linting for the application name
+          def create_lint_task!
+            application = @name
+            ruby = @ruby
+            exclude = @exclude
+            return if exclude.include?(:lint)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all linting software'
+                task lint: %w(ruby:lint) do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :ruby do
+                  desc "Run the ruby linting software against the #{application}'s codebase"
+                  task lint: %w(init_docker up_no_deps) do
+                    LOG.debug("Check for ruby linting errors in the #{application} codebase")
+
+                    options = []
+                    options << '-T' if Dev::Common.new.running_codebuild?
+                    Dev::Docker::Compose.new(services: application, options: options).exec(*ruby.lint_command)
+                  end
+
+                  namespace :lint do
+                    desc "Run the ruby linting software against the #{application}'s codebase and apply all available fixes"
+                    task fix: %w(init_docker up_no_deps) do
+                      LOG.debug("Check and fix all ruby linting errors in the #{application} codebase")
+
+                      options = []
+                      options << '-T' if Dev::Common.new.running_codebuild?
+                      Dev::Docker::Compose.new(services: application, options: options).exec(*ruby.lint_fix_command)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake task which runs all tests for the application name
+          def create_test_task!
+            application = @name
+            ruby = @ruby
+            exclude = @exclude
+            return if exclude.include?(:test)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all tests'
+                task test: [:'ruby:test'] do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :ruby do
+                  desc "Run all ruby tests against the #{application}'s codebase"
+                  task test: %w(init_docker up_no_deps) do
+                    LOG.debug("Running all ruby tests in the #{application} codebase")
+
+                    options = []
+                    options << '-T' if Dev::Common.new.running_codebuild?
+                    Dev::Docker::Compose.new(services: application, options: options).exec(*ruby.test_command)
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake task which runs the install command for the application packages
+          def create_install_task!
+            # Have to set a local variable to be accessible inside of the instance_eval block
+            application = @name
+            ruby = @ruby
+            exclude = @exclude
+            return if exclude.include?(:install)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                namespace :ruby do
+                  desc 'Install all npm packages'
+                  task install: %w(init_docker up_no_deps) do
+                    Dev::Docker::Compose.new(services: application).exec(*ruby.install_command)
+                  end
+                end
+              end
+            end
+          end
+
+          # Create the rake task which runs the security audits for the application packages
+          def create_audit_task!
+            # Have to set a local variable to be accessible inside of the instance_eval block
+            application = @name
+            ruby = @ruby
+            exclude = @exclude
+            return if exclude.include?(:audit)
+
+            DEV_COMMANDS_TOP_LEVEL.instance_eval do
+              namespace application do
+                desc 'Run all security audits'
+                task audit: [:'ruby:audit'] do
+                  # This is just a placeholder to execute the dependencies
+                end
+
+                namespace :ruby do
+                  desc 'Run Bundle Audit on the target application' \
+                       "\n\tuse MIN_SEVERITY=(info low moderate high critical) to fetch only severity type selected and above (default=high)." \
+                       "\n\tuse IGNORELIST=(comma delimited list of ids) removes the entry from the list."
+                  task audit: %w(init_docker up_no_deps) do
+                    opts = []
+                    opts << '-T' if Dev::Common.new.running_codebuild?
+
+                    # Retrieve results of the scan.
+                    data = Dev::Docker::Compose.new(services: application, options: opts, capture: true).exec(*ruby.audit_command)
+                    Dev::Ruby::Audit.new(data).to_report.check
+                  end
+
+                  # namespace :audit do
+                  #   desc 'Run NPM Audit fix command'
+                  #   task fix: %w(init_docker up_no_deps) do
+                  #     raise 'not implemented'
+                  #     # Dev::Docker::Compose.new(services: application).exec(*ruby.audit_fix_command)
+                  #   end
+                  # end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end