compote 0.2.2

data/lib/compote/cli/compose.rb

@@ -0,0 +1,41 @@
+module Compote
+
+  class CLI < Thor
+
+    COMPOSE_COMMANDS = %w()
+
+    COMPOTE_COMMANDS = %w( env help version )
+
+
+    compose_help = `docker-compose --help`
+
+    compose_help = compose_help.split "\n"
+
+    compose_help = compose_help.slice ( compose_help.index( "Commands:" ) + 1 )..-1
+
+    compose_help.each do | command_info |
+
+      command, description = command_info.strip.split( /\s+/, 2 )
+
+      next if COMPOTE_COMMANDS.include? command
+
+      COMPOSE_COMMANDS.push command
+
+
+      desc command, description
+
+      define_method "compose_#{ command }" do | *arguments |
+
+        next exec 'docker-compose', command, *arguments if %w(-h --help).include? arguments[ 0 ]
+
+        run_compose command, *arguments
+
+      end
+
+      map command => "compose_#{ command }"
+
+    end
+
+  end
+
+end

data/lib/compote/cli/env.rb

@@ -0,0 +1,23 @@
+module Compote
+
+  class CLI < Thor
+
+    desc 'env', 'View the resulted compose environment'
+
+    def env
+
+      compote_config = load_config
+
+      compose_environment = compote_config.compose_environment
+
+      say YAML.dump compose_environment
+
+    rescue Error => error
+
+      exit_with_error error
+
+    end
+
+  end
+
+end

data/lib/compote/cli/help.rb

@@ -0,0 +1,23 @@
+module Compote
+
+  class CLI < Thor
+
+    desc 'help', 'Get help on a command'
+
+    def help ( *arguments )
+
+      if COMPOSE_COMMANDS.include? arguments.first
+
+        exec 'docker-compose', 'help', *arguments
+
+      else
+
+        super *arguments
+
+      end
+
+    end
+
+  end
+
+end

data/lib/compote/cli/version.rb

@@ -0,0 +1,31 @@
+module Compote
+
+  class CLI < Thor
+
+    desc 'version', 'Show version information'
+
+    method_option :short, type: :boolean, desc: "Shows only Compote's and Compose's version numbers."
+
+    def version
+
+      compote_version = "compote version: #{ Compote::VERSION }"
+
+      compose_version = if options[ :short ]
+
+        "docker-compose version: #{ `docker-compose version --short` }"
+
+      else
+
+        `docker-compose version`
+
+      end
+
+      say compote_version
+
+      say compose_version
+
+    end
+
+  end
+
+end

data/lib/compote/config.rb

@@ -0,0 +1,272 @@
+module Compote
+
+  class Config
+
+    def initialize ( file_name )
+
+      @file_name = file_name
+
+      @directory_name = File.dirname file_name
+
+
+      data = YAML.load_file file_name
+
+      data = Schema.normalize self, data
+
+      @data = apply_extends data
+
+
+      @compose_settings = @data.reject { | key, value | %w( compote services ).include? key }
+
+      @compote_settings = @data.fetch 'compote', {}
+
+
+      @services_configs = {}
+
+      @data.fetch( 'services', {} ).each do | name, data |
+
+        service_config = ServiceConfig.new self, name, data
+
+        @services_configs[ name ] = service_config
+
+      end
+
+    end
+
+    def file_name
+
+      @file_name
+
+    end
+
+    def directory_name
+
+      @directory_name
+
+    end
+
+    def compose_version
+
+      @compose_settings.fetch 'version'
+
+    end
+
+    def compose_environment
+
+      environment = {}
+
+
+      environment_setting = @compote_settings.fetch 'environment', {}
+
+      environment_setting.each do | key, value |
+
+        environment[ key ] = ENV.fetch key, value
+
+      end
+
+
+      env_file_setting = @compote_settings.fetch 'env_file' do
+
+        env_file_setting = []
+
+        env_file_setting.push '.env' if File.exist? get_path '.env'
+
+        env_file_setting
+
+      end
+
+      env_file_setting.each do | env_file_path |
+
+        begin
+
+          env_file_path = get_path env_file_path
+
+          env_file_content = File.read env_file_path
+
+          env_file_variables = Dotenv::Parser.call env_file_content
+
+          env_file_variables.each do | key, value |
+
+            environment[ key ] = ENV.fetch key, value
+
+          end
+
+        rescue Errno::ENOENT => error
+
+          raise EnvFileOpenError.new error: error, config: self
+
+        rescue Dotenv::FormatError => error
+
+          raise EnvFileFormatError.new error: error, path: env_file_path, config: self
+
+        end
+
+      end
+
+
+      raise ProjectNameNotProvidedError.new unless environment[ 'COMPOSE_PROJECT_NAME' ] || ENV[ 'COMPOSE_PROJECT_NAME' ]
+
+
+      environment
+
+    end
+
+    def compose_file
+
+      file = Tempfile.new 'docker-compose.yml'
+
+      file.write YAML.dump compose_config
+
+      file.close
+
+      file
+
+    end
+
+    def commands
+
+      commands = {}
+
+      @compote_settings.fetch( 'commands', {} ).each do | name, command |
+
+        commands[ name ] = command
+
+      end
+
+      @services_configs.each do | service_name, service_config |
+
+        service_config.commands.each do | command_name, command |
+
+          commands[ "#{ service_name }:#{ command_name }" ] = command
+
+        end
+
+      end
+
+      commands
+
+    end
+
+    def compose_config
+
+      compose_config = {}
+
+      compose_config[ 'version' ] = @compose_settings.fetch 'version'
+
+      compose_config[ 'volumes' ] = @compose_settings.fetch 'volumes', {}
+
+      compose_config[ 'networks' ] = @compose_settings.fetch 'networks', {}
+
+
+      compose_config[ 'services' ] = {}
+
+      @services_configs.each do | name, service_config |
+
+        service_compose_config = service_config.compose_config
+
+        compose_config[ 'services' ].merge! service_compose_config.fetch( 'services', {} )
+
+        compose_config[ 'volumes' ].merge! service_compose_config.fetch( 'volumes', {} )
+
+        compose_config[ 'networks' ].merge! service_compose_config.fetch( 'networks', {} )
+
+      end
+
+
+      compose_config
+
+    end
+
+    def get_service_config ( name )
+
+      @services_configs.fetch name
+
+    rescue KeyError => error
+
+      raise ServiceNotFoundError.new service: name, config: self
+
+    end
+
+    def has_service_config? ( name )
+
+      @services_configs.has_key? name
+
+    end
+
+    def load_config ( path )
+
+      Config.load_config path, self
+
+    end
+
+    def get_path ( path )
+
+      Config.get_path path, self
+
+    end
+
+
+    @@configs = {}
+
+    def self.load_config ( path, origin_config = nil )
+
+      path = get_path path, origin_config
+
+      return origin_config if path == origin_config&.directory_name
+
+      config = @@configs[ path ]
+
+      raise ConfigRecursionError path: path, origin_config: origin_config, configs: configs if config.is_a? String
+
+      return config if config
+
+      @@configs[ path ] = origin_config&.file_name || ''
+
+      config = Config.new path
+
+      @@configs[ path ] = config
+
+      config
+
+    rescue Errno::ENOENT => error
+
+      raise ConfigOpenError.new error: error, origin_config: origin_config
+
+    end
+
+    def self.get_path ( path, origin_config = nil )
+
+      path = File.absolute_path path, origin_config&.directory_name
+
+      path = Pathname.new( path ).cleanpath.to_path
+
+      path
+
+    end
+
+
+    protected
+
+    def data
+
+      @data
+
+    end
+
+    def apply_extends ( initial_data )
+
+      Schema.apply_extends initial_data do | path |
+
+        config = load_config path
+
+        data = config.data
+
+        data
+
+      end
+
+    end
+
+  end
+
+end

data/lib/compote/error.rb

@@ -0,0 +1,144 @@
+module Compote
+
+  class Error < StandardError
+
+    attr_writer :message
+
+  end
+
+
+  class ConfigOpenError < Error
+
+    def initialize ( error:, origin_config: )
+
+      message = "Error loading config file: #{ error.message }"
+
+      message += "\n" + "required from #{ origin_config.file_name }" if origin_config
+
+      super message
+
+    end
+
+  end
+
+
+  class ConfigFormatError < Error
+
+    def initialize ( error:, data: )
+
+      message = "Error loading config file: #{ error.message }" + "\n\n" + "#{ YAML.dump data }"
+
+      super message
+
+    end
+
+  end
+
+
+  class ConfigRecursionError < Error
+
+    def initialize ( path:, origin_config:, configs: )
+
+      message = "Error loading config file: Recursive loading of config files - #{ path }."
+
+      message += "\n\n" + "Requiring trace:"
+
+      message += "\n" + "#{ path }"
+
+      requiring_path = origin_config.file_name
+
+      loop do
+
+        message += "\n" + "#{ requiring_path }"
+
+        requiring_path = configs[ requiring_path ]
+
+        break if requiring_path == path
+
+      end
+
+      super message
+
+    end
+
+  end
+
+
+  class EnvFileOpenError < Error
+
+    def initialize ( error:, config: )
+
+      message = "Error loading env file: #{ error.message }"
+
+      message += "\n" + "required from #{ config.file_name }"
+
+      super message
+
+    end
+
+  end
+
+
+  class EnvFileFormatError < Error
+
+    def initialize ( error:, path:, config: )
+
+      message = "Error loading env file: #{ error.message } - \"#{ path }\""
+
+      message += "\n" + "required from #{ config.file_name }"
+
+      super message
+
+    end
+
+  end
+
+
+  class ServiceNotFoundError < Error
+
+    attr_reader :service, :config
+
+
+    def initialize ( service:, config: )
+
+      @service = service
+
+      @config = config
+
+      message = "Error extending service: Service \"#{ service }\" not found in config \"#{ config.file_name }\"."
+
+      super message
+
+    end
+
+  end
+
+
+  class ProjectNameNotProvidedError < Error
+
+    def initialize
+
+      message = "Error running compote: Make sure that you provided env variable COMPOSE_PROJECT_NAME."
+
+      super message
+
+    end
+
+  end
+
+
+  class UndefinedCommandError < Error
+
+    def initialize ( service_name:, command_name:, config: )
+
+      message = "Error running compote command: Can't find command named \#{ command_name }\" for service \"#{ service_name }\" in config \"#{ config.file_name }\"."
+
+      message += "\n" + "Seems that config doesn't have a service with such name." unless config.has_service_config? service_name
+
+      super message
+
+    end
+
+  end
+
+end