djin 0.4.0 → 0.8.0

data/djin.yml

@@ -1,26 +1,35 @@
-djin_version: '0.2.0'
+djin_version: '0.8.0'
 
 _default_run_options: &default_run_options
   options: "--rm --entrypoint=''"
 
-test:
-  docker-compose:
-    service: app
-    run:
-      commands: "cd /usr/src/djin && rspec"
-      <<: *default_run_options
-
-sh:
-  docker-compose:
-    service: app
-    run:
-      commands: "sh"
-      <<: *default_run_options
-run:
-  docker-compose:
-    service: app
-    run:
-      commands: "sh -c '{{args}}'"
-      <<: *default_run_options
+tasks:
+  test:
+    description: Runs Specs
+    docker-compose:
+      service: app
+      run:
+        commands: "cd /usr/src/djin && rspec {{args}}"
+        <<: *default_run_options
+    aliases:
+      - rspec
 
+  sh:
+    description: Enter app service shell
+    docker-compose:
+      service: app
+      run:
+        commands: "sh"
+        <<: *default_run_options
+  run:
+    docker-compose:
+      service: app
+      run:
+        commands: "sh -c '{{args}}'"
+        <<: *default_run_options
 
+  release:
+    local:
+      run:
+        - verto tag up {{args}}
+        - bundle exec rake release

data/examples/djin.yml

@@ -1,27 +1,29 @@
 ---
-default:
-  docker:
-    image: "ruby:2.5"
-    run:
-      - "ruby -e 'puts \\\" Hello\\\"'"
-test:
-  docker-compose:
-    service: app
-    run:
-      commands: rspec
-      options: "--rm"
+djin_version: '0.8.0'
 
-script:
-  docker:
-    image: "ruby:2.6"
-    run:
-      commands:
-        - "ruby /scripts/my_ruby_script.rb"
-      options: "--rm -v $(pwd)/my_ruby_script.rb:/scripts/my_ruby_script.rb"
+tasks:
+  default:
+    docker:
+      image: "ruby:2.5"
+      run:
+        - "ruby -e 'puts \\\" Hello\\\"'"
+  test:
+    docker-compose:
+      service: app
+      run:
+        commands: rspec
+        options: "--rm"
 
+  script:
+    docker:
+      image: "ruby:2.6"
+      run:
+        commands:
+          - "ruby /scripts/my_ruby_script.rb"
+        options: "--rm -v $(pwd)/my_ruby_script.rb:/scripts/my_ruby_script.rb"
 
-with_build:
-  docker:
-    build: .
-    run:
-      - "ruby -e 'puts \" Hello\"'"
+  with_build:
+    docker:
+      build: .
+      run:
+        - "ruby -e 'puts \" Hello\"'"

data/exe/djin

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-Signal.trap("INT") { exit 2 }
+Signal.trap('INT') { exit 2 }
 
 require_relative '../lib/djin'
 

data/lib/djin.rb

@@ -1,20 +1,27 @@
-require "djin/version"
-require "pathname"
-require "yaml"
-require "dry-struct"
-require "dry-validation"
-require "vseries"
-require "dry/cli"
-require "mustache"
-require "djin/extensions/hash_extensions"
-require "djin/extensions/custom_predicates"
-require "djin/entities/types"
-require "djin/entities/task"
-require "djin/interpreter"
-require "djin/executor"
-require "djin/cli"
-require "djin/task_contract"
-require "djin/repositories/task_repository"
+# frozen_string_literal: true
+
+require 'djin/version'
+require 'pathname'
+require 'yaml'
+require 'dry-struct'
+require 'dry-validation'
+require 'vseries'
+require 'dry/cli'
+require 'mustache'
+require 'djin/extensions/hash_extensions'
+require 'djin/entities/types'
+require 'djin/entities/task'
+require 'djin/entities/file_config'
+require 'djin/interpreter/base_command_builder'
+require 'djin/interpreter/docker_command_builder'
+require 'djin/interpreter/docker_compose_command_builder'
+require 'djin/interpreter/local_command_builder'
+require 'djin/interpreter'
+require 'djin/config_loader'
+require 'djin/executor'
+require 'djin/cli'
+require 'djin/task_contract'
+require 'djin/repositories/task_repository'
 
 module Djin
   class Error < StandardError; end
@@ -22,15 +29,16 @@ module Djin
   def self.load_tasks!(path = Pathname.getwd.join('djin.yml'))
     abort 'Error: djin.yml not found' unless path.exist?
 
-    djin_file = YAML.safe_load(path.read, [], [], true)
+    file_config = ConfigLoader.load!(path.read)
 
-    tasks = Djin::Interpreter.load!(djin_file)
+    # TODO: Make all tasks be under 'tasks' key, passing only the tasks here
+    tasks = Interpreter.load!(file_config)
 
     @task_repository = TaskRepository.new(tasks)
     CLI.load_tasks!(tasks)
-
-  rescue Djin::Interpreter::InvalidConfigurationError => ex
-    abort(ex.message)
+  rescue Djin::Interpreter::InvalidConfigurationError => e
+    error_name = e.class.name.split('::').last
+    abort("[#{error_name}] #{e.message}")
   end
 
   def self.tasks
@@ -41,4 +49,3 @@ module Djin
     @task_repository ||= TaskRepository.new
   end
 end
-

data/lib/djin/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Djin
   class CLI
     extend Dry::CLI::Registry
@@ -5,21 +7,21 @@ module Djin
     def self.load_tasks!(tasks)
       tasks.each do |task|
         command = Class.new(Dry::CLI::Command) do
-          desc "Runs: #{task.command}"
+          desc task.description
 
           define_method(:task) { task }
 
-          def call(args: [], **)
-            Executor.new(args: args).call(task)
+          def call(**)
+            Executor.new.call(task)
           end
         end
 
-        register task.name, command
+        register(task.name, command, aliases: task.aliases)
       end
     end
 
     class Version < Dry::CLI::Command
-      desc "Prints Djin Version"
+      desc 'Prints Djin Version'
 
       def call(*)
         puts Djin::VERSION

data/lib/djin/config_loader.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Djin
+  # TODO: Refactor this class to be the Interpreter
+  #       class and use the current interpreter as
+  #       a TaskLoader
+  class ConfigLoader
+    using Djin::HashExtensions
+    RESERVED_WORDS = %w[djin_version variables tasks].freeze
+
+    def self.load!(template_file)
+      new(template_file).load!
+    end
+
+    def initialize(template_file)
+      @template_file = template_file
+    end
+
+    def load!
+      validate_version!
+
+      file_config
+    end
+
+    private
+
+    def file_config
+      FileConfig.new(
+        djin_version: version,
+        variables: variables,
+        tasks: tasks,
+        raw_tasks: raw_tasks
+      )
+    end
+
+    def raw_djin_config
+      @raw_djin_config ||= yaml_load(@template_file)
+    rescue Psych::SyntaxError => e
+      raise Interpreter::InvalidConfigFileError, e.message
+    end
+
+    def rendered_djin_config
+      @rendered_djin_config ||= begin
+                                  locals = env.merge(variables)
+
+                                  rendered_yaml = Mustache.render(@template_file,
+                                                                  args: args.join(' '),
+                                                                  args?: args.any?,
+                                                                  **locals)
+                                  yaml_load(rendered_yaml)
+                                end
+    end
+
+    def version
+      # TODO: Deprecates djin_version and use version instead
+      @version || raw_djin_config['djin_version']
+    end
+
+    def variables
+      @variables ||= raw_djin_config['variables']&.symbolize_keys || {}
+    end
+
+    def tasks
+      rendered_djin_config['tasks'] || legacy_tasks
+    end
+
+    def raw_tasks
+      raw_djin_config['tasks'] || legacy_raw_tasks
+    end
+
+    def legacy_tasks
+      warn '[DEPRECATED] Root tasks are deprecated and will be removed in Djin 1.0.0,' \
+           ' put the tasks under \'tasks\' keyword'
+
+      rendered_djin_config.except(*RESERVED_WORDS).reject { |task| task.start_with?('_') }
+    end
+
+    def legacy_raw_tasks
+      raw_djin_config.except(*RESERVED_WORDS).reject { |task| task.start_with?('_') }
+    end
+
+    def args
+      index = ARGV.index('--')
+
+      return [] unless index
+
+      ARGV.slice((index + 1)..ARGV.size)
+    end
+
+    def env
+      @env ||= ENV.to_h.symbolize_keys
+    end
+
+    def yaml_load(text)
+      YAML.safe_load(text, [], [], true)
+    end
+
+    def validate_version!
+      raise Interpreter::MissingVersionError, 'Missing djin_version' unless version
+
+      return if file_config.version_supported?
+
+      raise Interpreter::VersionNotSupportedError, "Version #{version} is not supported, use #{Djin::VERSION} or higher"
+    end
+  end
+end

data/lib/djin/entities/file_config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Djin
+  class FileConfig < Dry::Struct
+    attribute :djin_version, Types::String
+    attribute :variables, Types::Hash.optional.default({}.freeze)
+    attribute :tasks, Types::Hash
+    attribute :raw_tasks, Types::Hash
+    # TODO: Add env and args
+
+    include Dry::Equalizer(:djin_version, :variables, :tasks, :raw_tasks)
+
+    def version_supported?
+      Vseries::SemanticVersion.new(Djin::VERSION) >= Vseries::SemanticVersion.new(djin_version)
+    end
+  end
+end

data/lib/djin/entities/task.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 module Djin
   class Task < Dry::Struct
     attribute :name, Types::String
     attribute :description, Types::String.optional.default(nil)
     attribute :build_command, Types::String.optional.default(nil)
     attribute :command, Types::String.optional.default(nil)
+    attribute :raw_command, Types::String.optional.default(nil)
+    attribute :aliases, Types::Array.of(Types::String).optional.default([].freeze)
     attribute :depends_on, Types::Array.of(Types::String).optional.default([].freeze)
 
-    def ==(other)
-      name == other.name &&
-        command == other.command &&
-        build_command == other.build_command
-    end
+    include Dry::Equalizer(:name, :command, :build_command)
   end
 end

data/lib/djin/entities/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Djin
   module Types
     include Dry.Types()

data/lib/djin/executor.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Djin
   class Executor
-    def initialize(task_repository: Djin.task_repository, args: [])
+    def initialize(task_repository: Djin.task_repository)
       @task_repository = task_repository
-      @args = args
     end
 
     def call(*tasks)
@@ -23,15 +24,7 @@ module Djin
     end
 
     def run(command)
-      command_with_args = Mustache.render(command,
-                                          args: @args.join(' '),
-                                          args?: @args.any?,
-                                          **env)
-      system command_with_args
-    end
-
-    def env
-      @env = ENV.to_h.map {|k,v| [k.to_sym, v]}.to_h
+      system command
     end
   end
 end

data/lib/djin/extensions/hash_extensions.rb

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
 module Djin
   module HashExtensions
     refine Hash do
       def except(*keys)
-        reject { |key,_| keys.include?(key) }
+        reject { |key, _| keys.include?(key) }
+      end
+
+      def symbolize_keys
+        map { |key, value| [key.to_sym, value] }.to_h
       end
     end
   end

data/lib/djin/interpreter.rb

@@ -1,34 +1,36 @@
+# frozen_string_literal: true
+
 module Djin
   class Interpreter
     using Djin::HashExtensions
 
-    RESERVED_WORDS = %w[djin_version _default_options].freeze
-
+    # TODO: Move Errors to ConfigLoader
     InvalidConfigurationError = Class.new(StandardError)
+    InvalidConfigFileError = Class.new(InvalidConfigurationError)
     MissingVersionError = Class.new(InvalidConfigurationError)
     VersionNotSupportedError = Class.new(InvalidConfigurationError)
     InvalidSyntaxError = Class.new(InvalidConfigurationError)
 
     class << self
-      def load!(params)
-        version = params['djin_version']
-        raise MissingVersionError, 'Missing djin_version' unless version
-        raise VersionNotSupportedError, "Version #{version} is not supported, use #{Djin::VERSION} or higher" unless version_supported?(version)
-
-        tasks_params = params.except(*RESERVED_WORDS).reject { |task| task.start_with?('_') }
+      def load!(file_config)
         contract = TaskContract.new
 
-        tasks_params.map do |task_name, options|
+        file_config.tasks.map do |task_name, options|
           result = contract.call(options)
 
           raise InvalidSyntaxError, { task_name.to_sym => result.errors.to_h } if result.failure?
 
           command, build_command = build_commands(options, task_name: task_name)
 
+          raw_command, = build_commands(file_config.raw_tasks[task_name], task_name: task_name)
+
           task_params = {
             name: task_name,
             build_command: build_command,
+            description: options['description'] || "Runs: #{raw_command}",
             command: command,
+            raw_command: raw_command,
+            aliases: options['aliases'],
             depends_on: options['depends_on']
           }.compact
 
@@ -42,62 +44,13 @@ module Djin
         # Validate that only one ot the two is passed
         docker_params = params['docker']
         docker_compose_params = params['docker-compose']
+        local_params = params['local']
 
-        return build_docker_commands(docker_params, task_name: task_name) if docker_params
-        build_docker_compose_commands(docker_compose_params) if docker_compose_params
-      end
-
-      def build_docker_commands(params, task_name:)
-        current_folder_name = Pathname.getwd.basename.to_s
-        image = params['image'] || "djin_#{current_folder_name}_#{task_name}"
-
-        build_params = params['build']
-
-        if build_params.is_a?(Hash)
-          build_context = build_params['context']
-          build_options = build_params['options']
-        end
-
-        build_context ||= build_params
-
-        run_command, run_options = build_run_params(params['run'])
-
-        command = %Q{docker run #{run_options} #{image} sh -c "#{run_command}"}.squeeze(' ')
-
-        build_command = "docker build #{build_context} #{build_options} -t #{image}".squeeze(' ') if build_context
-
-        [command, build_command]
-      end
-
-      def build_docker_compose_commands(params)
-        service = params['service']
-
-        compose_options = params['options']
-
-        run_command, run_options = build_run_params(params['run'])
-
-        [%Q{docker-compose #{compose_options} run #{run_options} #{service} sh -c "#{run_command}"}.squeeze(' '), nil]
-      end
-
-      def build_run_params(run_params)
-        run_command = run_params
-
-        if run_params.is_a?(Hash)
-          run_command = run_params['commands']
-          run_options = run_params['options']
-        end
-
-        run_command =  run_command.join(' && ') if run_command.is_a?(Array)
-
-        [run_command, run_options]
-      end
-
-      def validate_version!(version)
-
-      end
+        # TODO: Refactor to use chain of responsability
+        return DockerCommandBuilder.call(docker_params, task_name: task_name) if docker_params
+        return DockerComposeCommandBuilder.call(docker_compose_params) if docker_compose_params
 
-      def version_supported?(version)
-        Vseries::SemanticVersion.new(Djin::VERSION) >= Vseries::SemanticVersion.new(version)
+        LocalCommandBuilder.call(local_params) if local_params
       end
     end
   end