ass_launcher 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 26b10b3da2020233f1272057ad37c5104c75733e
-  data.tar.gz: b6487231896541b539dfce02af37bd17c1506a3c
+  metadata.gz: 5f34851c8fc8124870441ee8daa7551e10a50ea2
+  data.tar.gz: fd4b54bd0505ba57b8ab32cad6c47d1b5591cacd
 SHA512:
-  metadata.gz: d15a7c46c67149e3221cd878eec66d5936973230f516f136c01ae0fdd724917e645f7d4e4dc4bc1bb745503b26b46d2576fde1b326a28ad615c2544f22979be5
-  data.tar.gz: 2c4b441db121c659012f57025ac99b69e778af0db4b107bed507d960ae007d6b60344416c830e8467d395d4570ac0a7d1521433a44309961f6eebd1a1f6123b0
+  metadata.gz: 97b9af2a7bfe6c63e8148e850186af7c3a4804ed191562d054dec877cf5f5886fa2b894175bebebb7012cc81ce5c221c1554c70b94b282b9be52009be21e415b
+  data.tar.gz: 0a98039ec4250d870fd78c561d0039b0ee85dbd35f58d5fb130fe4577176ff0cde719a437ecebc22760568f7d3108c331b738af3bdc2b792a26438808dcc0cda

data/.rubocop.yml

@@ -0,0 +1,20 @@
+Style/SignalException:
+  Enabled: false
+
+Layout/EndOfLine:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 17
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: false

data/README.md

@@ -15,6 +15,8 @@ In `Linux` don't support `OLE` feature. Don't known why I told it ;)
 
 ## Quick start
 
+### Using `AssLauncher` as a library
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -59,6 +61,21 @@ end
 main ARGV[0]
 ```
 
+### Command line utility `ass-launcher`
+
+From version `0.3.0` `AssLauncher` provides console tool `ass-launcher` wich has
+features:
+
+- make new 1C:Enterprise application instance (aka information base)
+- run 1C:Enterprise
+- show help about 1C:Enterprise CLI parameters
+- and some more
+
+For more info about `ass-launcher` execute:
+
+    $ass-launcer --help
+
+
 ## Usage
 
 ### Examples

data/ass_launcher.gemspec

@@ -26,6 +26,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "inifile"
   spec.add_dependency "methadone"
   spec.add_dependency "addressable", "= 2.4.0"
+  spec.add_dependency "clamp"
+  spec.add_dependency "colorize"
+  spec.add_dependency "command_line_reporter", '>=3.0'
 
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
@@ -33,6 +36,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry"
   spec.add_development_dependency "mocha", "= 1.1.0"
   spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "clamp"
   spec.add_development_dependency "coderay"
 end

data/bin/lib/dev_helper.rb

@@ -39,10 +39,13 @@ module DevHelper
     require_relative './dev_helper/designer'
 
     class Main < Clamp::Command
+      include AssLauncher::Enterprise::CliDefsLoader
 
-      subcommand 'show-version', 'show ass_launcher version' do
+      subcommand 'show-version', 'show ass_launcher and known 1C:Enterprise versions' do
         def execute
-          $stdout.puts AssLauncher::VERSION
+          $stdout.puts "AssLauncher::VERSION: #{AssLauncher::VERSION}"
+          $stdout.puts "Known 1C:Enterprise CLI definitions:"
+          $stdout.puts " - #{defs_versions.map(&:to_s).join("\n - ")}"
         end
       end
       subcommand 'cli-def-report',

data/exe/ass-launcher

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'ass_launcher'
+require 'ass_launcher/cmd'
+
+AssLauncher::Cmd::Main.run

data/lib/ass_launcher/cmd.rb

@@ -0,0 +1,903 @@
+require 'clamp'
+module AssLauncher
+  # AssLauncher command-line untils
+  # @example
+  #   $ass-launcher --help
+  # @api private
+  #
+  module Cmd
+    # Colorize string for console output
+    # It's stupid wrapper for ColorizedString
+    # @api private
+    module Colorize
+      require 'colorized_string'
+
+      # rubocop:disable Style/MethodMissing
+      def self.method_missing(m, s)
+        colorized(s).send(m)
+      end
+      # rubocop:enable Style/MethodMissing
+
+      def self.colorized(mes)
+        ColorizedString[mes]
+      end
+    end
+
+    # @api private
+    module Support
+      # Mixin
+      # @api private
+      module SrvStrParser
+        # Parse string like +user:password@host:port+
+        # @param s [String]
+        # @return [Array] ['host:port', 'user', 'password']
+        def parse_srv_str(s)
+          split = s.split('@')
+          fail ArgumentError if split.size > 2
+
+          host = split.pop
+          return [host, nil, nil] if split.size.zero?
+
+          split = split[0].split(':')
+          fail ArgumentError if split.size > 2
+
+          user = split.shift
+          pass = split.shift
+
+          [host, user, pass]
+        end
+      end
+
+      # Mixin for validate version
+      # @api private
+      module VersionValidator
+        include AssLauncher::Enterprise::CliDefsLoader
+
+        def validate_version
+          return known_version.sort.last if version.to_s.empty?
+          unless known_version.include? version
+            signal_usage_error "Unknown 1C:Enterprise v#{version}\n"\
+              "Execute `ass-launcher show-version' command"
+          end
+          version
+        end
+
+        def known_version
+          @known_version ||= defs_versions.sort
+        end
+      end
+
+      # Mixin for cli reporters
+      # @api private
+      module AcceptedValuesGet
+        def accepted_values_get
+          xxx_list_keys(:switch, param) + xxx_list_keys(:chose, param)
+        end
+
+        def xxx_list_keys(list, p)
+          list = p.send("#{list}_list".to_sym)
+          return list.keys if list
+          []
+        end
+      end
+    end
+
+    # @api private
+    # Abstract things
+    module Abstract
+      # Abstarct subcommand
+      # @api private
+      class SubCommand < Clamp::Command
+        # :nodoc:
+        module Declaration
+          def subcommand_(klass)
+            subcommand(klass.command_name, klass._banner, klass)
+          end
+
+          def declare_subcommands
+            self::SubCommands.constants.each do |c|
+              subcommand_ self::SubCommands.const_get(c)
+            end
+          end
+        end
+
+        extend Declaration
+
+        # :nocov:
+        def self.command_name
+          fail 'Abstract'
+        end
+
+        def self._banner
+          fail 'Abstract'
+        end
+        # :nocov:
+      end
+
+      # Mixin
+      # @api private
+      module ClientMode
+        def parrent_command
+          invocation_path.to_s.split[1]
+        end
+
+        def client
+          case parrent_command
+          when 'designer' then :thick
+          when 'thick' then :thick
+          when 'thin' then :thin
+          when 'web' then :web
+          when 'makeib' then :thick
+          end
+        end
+
+        def mode
+          case parrent_command
+          when 'designer' then :designer
+          when 'thick' then :enterprise
+          when 'thin' then :enterprise
+          when 'web'  then :webclient
+          when 'makeib' then :createinfobase
+          end
+        end
+      end
+
+      # Mixin
+      # @api private
+      module BinaryWrapper
+        include AssLauncher::Api
+        include ClientMode
+
+        def binary_wrapper
+          binary_get || (fail Clamp::ExecutionError
+            .new(not_inst_message, invocation_path, 1))
+        end
+
+        def not_inst_message
+          "1C:Enterprise #{client} v #{vrequrement} not installed"
+        end
+        private :not_inst_message
+
+        def vrequrement
+          return '' unless version
+          case version.segments.size
+          when 3 then "~> #{version}.0"
+          when 2 then "~> #{version}.0"
+          else "= #{version}"
+          end
+        end
+
+        def binary_get
+          case client
+          when :thick then thicks(vrequrement).last
+          when :thin then thins(vrequrement).last
+          end
+        end
+        private :binary_get
+
+        # rubocop:disable all
+        def dry_run(cmd)
+          r = "#{cmd.cmd.gsub(' ', '\\ ')} "
+          if mode == :createinfobase
+            r << cmd.args.join(' ')
+          else
+            r << cmd.args.map do |a|
+              unless a =~ %r{^(/|-|'|"|DESIGNER|ENTERPRISE)}
+                "\'#{a}\'" unless a.to_s.empty?
+              else
+                a
+              end
+            end.join(' ')
+          end
+        end
+
+        def run_enterprise(cmd)
+          if respond_to?(:dry_run?) && dry_run?
+            puts Colorize.yellow(dry_run(cmd))
+          else
+            begin
+              cmd.run.wait.result.verify!
+            rescue AssLauncher::Support::Shell::RunAssResult::RunAssError => e
+              raise Clamp::ExecutionError.new(e.message, invocation_path,
+                cmd.process_holder.result.exitstatus)
+            end
+          end
+          cmd
+        end
+        # rubocop:enable all
+      end
+
+      # @api private
+      module Option
+        # Mixin
+        # Command option
+        module SearchPath
+          def self.included(base)
+            base.option %w[--search-path -I], 'PATH',
+                        'specify 1C:Enterprise installation path' do |s|
+              AssLauncher.config.search_path = s
+              s
+            end
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Version
+          def self.included(base)
+            base.option %w[--version -v], 'VERSION',
+                        "specify 1C:Enterprise version requiremet.\n"\
+                        " Expected full version number or only major\n"\
+                        ' part of version number' do |s|
+              Gem::Version.new(s)
+            end
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Verbose
+          def self.included(base)
+            base.option '--verbose', :flag, 'show more information'
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Query
+          def self.included(base)
+            base.option %w[--query -q], 'REGEX',
+                        'regular expression based filter' do |s|
+              begin
+                Regexp.new(s, Regexp::IGNORECASE)
+              rescue RegexpError => e
+                fail ArgumentError, e.message
+              end
+            end
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Dbms
+          # rubocop:disable all
+          def self.included(base)
+            dbtypes = AssLauncher::Support::ConnectionString::DBMS_VALUES\
+              + ['File']
+
+            define_method :valid_db_types do
+              dbtypes
+            end
+
+            base.option '--dbms', 'DB_TYPE',
+                        "db type: #{dbtypes}.\nValue \"File\""\
+                        ' for make file infobase', default: 'File' do |s|
+              raise ArgumentError,
+                "valid values: [#{valid_db_types.join(' ')}]" unless\
+                valid_db_types.include? s
+              s
+            end
+          end
+          # rubocop:enable all
+        end
+
+        # Mixin
+        # Command option
+        module Dbsrv
+          attr_reader :dbsrv_user, :dbsrv_pass, :dbsrv_host
+          include Support::SrvStrParser
+          def parse_dbsrv(s)
+            @dbsrv_host, @dbsrv_user, @dbsrv_pass = parse_srv_str(s)
+          end
+
+          def self.included(base)
+            base.option '--dbsrv', 'user:pass@dbsrv', 'db server address' do |s|
+              parse_dbsrv s
+              s
+            end
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Esrv
+          attr_reader :esrv_user, :esrv_pass, :esrv_host
+          include Support::SrvStrParser
+          def parse_esrv(s)
+            @esrv_host, @esrv_user, @esrv_pass = parse_srv_str(s)
+          end
+
+          def self.included(base)
+            base.option '--esrv', 'user:pass@esrv',
+                        'enterprise server address' do |s|
+              parse_esrv(s)
+              s
+            end
+          end
+        end
+
+        # Mixin
+        # Command option
+        module User
+          def self.included(base)
+            base.option %w[--user -u], 'NAME', 'infobase user name'
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Password
+          def self.included(base)
+            base.option %w[--password -p], 'PASSWORD', 'infobase user password'
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Pattern
+          def self.included(base)
+            base.option %w[--pattern -P], 'PATH',
+                        'Template for make infobase.'\
+                        ' Path to .cf, .dt files' do |s|
+              fail ArgumentError, "Path not exist: #{s}" unless File.exist?(s)
+              s
+            end
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Uc
+          def self.included(base)
+            base.option '--uc', 'LOCK_CODE', 'infobase lock code'
+          end
+        end
+
+        # Mixin
+        # Command option
+        module DryRun
+          def self.included(base)
+            base.option %w[--dry-run], :flag,
+                        'will not realy run 1C:Enterprise only puts cmd string'
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Raw
+          def parse_raw(s)
+            split = s.split(%r{(?<!\\),\s}).map(&:strip)
+
+            split.map do |pv|
+              fail ArgumentError, "Parse error in: #{pv}" unless\
+                pv =~ %r{^(/|-)}
+              pv =~ %r{^(\/|-)([^\s]+)+(.*)?}
+              ["#{$1}#{$2}", $3.strip].map { |i| i.gsub('\\,', ',') }
+            end
+          end
+
+          def raw_param
+            r = []
+            raw_list.each do |params|
+              r += params
+            end
+            r
+          end
+
+          def self.included(base)
+            description = "other 1C CLI parameters in raw(native) format.\n"\
+              'Parameters and their arguments must be delimited'\
+              " comma-space sequence: `, '\n"\
+              "If values includes comma comma must be slashed `\\\\,'\n"\
+              'WARNING: correctness of parsing will not guaranteed!'
+
+            base.option '--raw', '"/Par VAL, -SubPar VAL"', description,
+                        multivalued: true do |s|
+              parse_raw s
+            end
+          end
+        end
+
+        # Mixin
+        # Command option
+        module ShowAppiaredOnly
+          def self.included(base)
+            base.option ['--show-appiared-only', '-a'], :flag,
+                        'show parameters which appiared in --version only'
+          end
+        end
+
+        # Mixin
+        # Command option
+        module DevMode
+          def self.included(base)
+            base.option ['--dev-mode', '-d'], :flag,
+                        "for developers mode. Show DSL methods\n"\
+                        " specifications for builds commands in ruby scripts\n"
+          end
+        end
+
+        # Mixin
+        # Command option
+        module Format
+          def self.included(base)
+            base.option ['--format', '-f'], 'ascii|csv', 'output format',
+                        default: :ascii do |s|
+              fail ArgumentError, "Invalid format `#{s}'" unless\
+                %w[csv ascii].include? s
+              s.to_sym
+            end
+          end
+        end
+      end
+
+      # @api private
+      # rubocop:disable Style/ClassAndModuleCamelCase
+      module Parameter
+        # Mixin
+        # Command parameter
+        module IB_PATH
+          def self.included(base)
+            base.parameter 'IB_PATH', 'path to infobase like a strings'\
+                            " 'tcp://srv/ref' or 'http[s]://host/path'"\
+                            " or 'path/to/ib'", attribute_name: :ib_path do |s|
+              s
+            end
+          end
+        end
+
+        # Mixin
+        # Command parameter
+        module IB_PATH_NAME
+          def self.included(base)
+            base.parameter 'IB_PATH | IB_NAME',
+                           'PATH for file or NAME for server infobase',
+                           attribute_name: :ib_path do |s|
+              s
+            end
+          end
+        end
+      end
+      # rubocop:enable Style/ClassAndModuleCamelCase
+
+      # Abstarct cli-help command
+      # @api private
+      class Cli < SubCommand
+        include Support::VersionValidator
+        include Option::Version
+        include Option::ShowAppiaredOnly
+        include Option::DevMode
+        include Option::Query
+        include Option::Format
+        include Option::Verbose
+        include ClientMode
+
+        # Reporter
+        # @api private
+        # rubocop:disable Metrics/ClassLength
+        class Report
+          USAGE_COLUMNS = [:usage,
+                           :argument,
+                           :parent,
+                           :group,
+                           :desc].freeze
+
+          DEVEL_COLUMNS = [:parameter,
+                           :dsl_method,
+                           :accepted_values,
+                           :parent,
+                           :param_klass,
+                           :group,
+                           :require,
+                           :desc].freeze
+
+          # Report's row
+          class Row
+            include Support::AcceptedValuesGet
+
+            (USAGE_COLUMNS + DEVEL_COLUMNS).uniq.each do |col|
+              attr_accessor col
+            end
+
+            attr_reader :param
+            def initialize(param)
+              @param = param
+              fill
+            end
+
+            # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+            # rubocop:disable Metrics/MethodLength
+            def fill
+              self.parameter = basic_usage
+              self.dsl_method = dsl_method_get
+              self.parent = param.parent
+              self.require = param.binary_matcher.requirement
+              self.accepted_values = accepted_values_get
+                .to_s.gsub(/(^\[|\]$)/, '')
+              self.usage, self.argument = usage_full
+              self.desc = param.desc
+              self.param_klass = param.class.name.split('::').last
+              self.group = param.group
+            end
+            private :fill
+
+            def usage_full
+              case param.class.name.split('::').last
+              when 'Switch' then
+                ["#{basic_usage}(#{accepted_values_get.join('|')})"]
+              when 'Chose' then
+                [basic_usage, accepted_values_get.join(', ')]
+              when 'StringParam' then [basic_usage, 'VALUE']
+              when 'Path' then [basic_usage, 'PATH']
+              when 'Flag' then [basic_usage]
+              when 'PathTwice' then [basic_usage, 'PATH PATH']
+              else basic_usage
+              end
+            end
+            # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+            # rubocop:enable Metrics/MethodLength
+
+            def basic_usage
+              return "  #{param.name}" if param.parent
+              param.name
+            end
+
+            def dsl_method_get
+              method = param.name.gsub(%r{^\s*(/|-)}, '_')
+              return "  #{method}" if param.parent
+              method
+            end
+
+            def to_csv(columns)
+              r = ''
+              columns.each do |col|
+                r << "\"#{send(col).to_s.tr('"', '\'')}\";"
+              end
+              r.gsub(/;$/, '')
+            end
+          end
+
+          attr_reader :client, :mode, :version, :query, :appiared_only,
+                      :dev_mode
+          # rubocop:disable Metrics/ParameterLists
+          def initialize(client, mode, version, appiared_only, query, dev_mode)
+            @client = client
+            @mode = mode
+            @version = version
+            @appiared_only = appiared_only
+            @query = query
+            @dev_mode = dev_mode
+          end
+          # rubocop:enable Metrics/ParameterLists
+
+          def clients?(p)
+            p.binary_matcher.clients.include? client
+          end
+
+          def modes?(p)
+            p.modes.include? mode
+          end
+
+          def version?(p)
+            return true if version.nil?
+            if appiared_only
+              p.binary_matcher.requirement.to_s =~ /^>=\s*#{version}/
+            else
+              p.match_version?(version) unless appiared_only
+            end
+          end
+
+          def match?(p)
+            clients?(p) && modes?(p) && version?(p)
+          end
+
+          def not_filtred?(p)
+            return true unless query
+            coll_match?(:desc, p) || coll_match?(:parent, p) || \
+              coll_match?(:name, p)
+          end
+
+          def coll_match?(prop, p)
+            !(p.send(prop).to_s =~ query).nil?
+          end
+
+          def groups
+            AssLauncher::Enterprise::Cli::CliSpec.cli_def.parameters_groups
+          end
+
+          def grouped_rows
+            r = {}
+            groups.each do |gname, _|
+              r[gname] = rows.select { |row| row.group == gname }
+                .sort_by { |row| row.param.full_name }
+            end
+            r
+          end
+
+          def rows
+            @rows ||= execute
+          end
+
+          def select_parameters
+            r = []
+            AssLauncher::Enterprise::Cli::CliSpec
+              .cli_def.parameters.parameters.each do |p|
+              if match?(p) && not_filtred?(p)
+                r << p
+                r << p.parent if p.parent && !r.include?(p.parent)
+              end
+            end
+            r
+          end
+
+          def execute
+            r = select_parameters.map do |p|
+              Row.new(p)
+            end
+            r.sort_by { |row| row.param.full_name }
+          end
+
+          def max_col_width(col, rows)
+            [rows.map do |r|
+              r.send(col).to_s.length
+            end.max, col.to_s.length].max
+          end
+
+          require 'io/console'
+          def term_width(trim = 0)
+            IO.console.winsize[1] - trim
+          end
+
+          def eval_width(col, total, r, trim, rows)
+            [(term_width(trim) - r.values.inject(0) { |i, o| o + i }) / total,
+             max_col_width(col, rows)].min
+          end
+
+          # rubocop:disable Style/ConditionalAssignment
+          def columns_width(columns, rows)
+            total = columns.size + 1
+            columns.each_with_object({}) do |col, r|
+              total -= 1
+              if [:usage, :parameter, :dsl_method].include? col
+                r[col] = max_col_width(col, rows)
+              else
+                r[col] = eval_width(col, total, r,
+                                    4 + (columns.size - 1) * 3, rows)
+              end
+            end
+          end
+
+          def main_header
+            if dev_mode
+              r = 'DSL METHODS'
+            else
+              r = 'CLI PARAMETERS'
+            end
+            r << " AVAILABLE FOR: \"#{client}\" CLIENT V#{version}"
+            r << " IN \"#{mode}\" RUNING MODE" if client == :thick
+            r.upcase
+          end
+          # rubocop:enable Style/ConditionalAssignment
+
+          def filter_header
+            "FILTERED BY: #{query}" if query
+          end
+
+          # rubocop:disable all
+          # @doto: refactoring and tests require
+          def to_table(columns)
+            require 'command_line_reporter'
+            extend CommandLineReporter
+
+            header title: main_header, width: main_header.length, rule: true,
+                   align: 'center', bold: true, spacing: 0
+
+            header title: filter_header, width: filter_header.length, rule: true,
+                   align: 'center', bold: false, color: 'yellow', spacing: 0 if\
+                   filter_header
+
+            grouped_rows.each do |gname, rows|
+              next if rows.size.zero?
+              table(border: true, encoding: :ascii) do
+                header title: "PARAMTERS GROUP: \"#{groups[gname][:desc]}\"",
+                  bold: true
+
+                row header: true do
+                  columns_width(columns, rows).each do |col, width|
+                    column(col.upcase, width:  width)
+                  end
+                end
+                rows.each do |row_|
+                  row do
+                    columns.each do |col|
+                      column(row_.send(col))
+                    end
+                  end
+                end
+              end
+            end
+            nil
+          end
+          # rubocop:enable all
+
+          def to_csv(columns)
+            r = "#{columns.join(';')}\n"
+            rows.each do |row|
+              r << row.to_csv(columns)
+              r << "\n"
+            end
+            r
+          end
+        end
+        # rubocop:enable Metrics/ClassLength
+
+        def self.command_name
+          'cli-help'
+        end
+
+        def self._banner
+          'show help for 1C:Enterprise CLI parameters'
+        end
+
+        def columns
+          cols = dev_mode? ? Report::DEVEL_COLUMNS : Report::USAGE_COLUMNS
+          cols -= [:parent, :parameter, :group, :require] unless verbose?
+          cols
+        end
+
+        def formating(report)
+          return report.to_table(columns) if format == :ascii
+          report.to_csv(columns)
+        end
+
+        def execute
+          $stdout.puts formating Report.new(client, mode, validate_version,
+                                            show_appiared_only?, query,
+                                            dev_mode?)
+        end
+      end
+
+      # Mixin
+      # @api private
+      module ParseIbPath
+        include AssLauncher::Api
+        require 'uri'
+        def connection_string
+          case ib_path
+          when %r{https?://}i then cs_http(ws: ib_path)
+          when %r{tcp://}i then parse_tcp_path
+          else cs_file(file: ib_path)
+          end
+        end
+
+        def parse_tcp_path
+          u = URI(ib_path)
+          cs_srv(srvr: "#{u.host}:#{u.port}", ref: u.path.gsub(%r{^/}, ''))
+        end
+      end
+
+      # Abstarct run command
+      # @api private
+      class Run < SubCommand
+        include Option::Version
+        include Option::DryRun
+        include Option::SearchPath
+        include Option::User
+        include Option::Password
+        include Option::Uc
+        include Option::Raw
+        include BinaryWrapper
+        include ParseIbPath
+
+        def self.command_name
+          'run'
+        end
+
+        def self._banner
+          'run 1C:Enterprise'
+        end
+
+        def command_(&block)
+          if client == :thin
+            binary_wrapper.command((raw_param.flatten || []), &block)
+          else
+            binary_wrapper.command(mode, (raw_param.flatten || []), &block)
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def make_command
+          usr = user
+          pass = password
+          uc_ = uc
+          cs = connection_string
+          cmd = command_ do
+            connection_string cs
+            _N usr if usr
+            _P pass if pass
+            _UC uc_ if uc_
+            _AppAutoCheckVersion(:-) if Gem::Requirement.new('>= 8.3.8')
+              .satisfied_by? binary_wrapper.version
+          end
+          cmd
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def execute
+          cmd = run_enterprise(make_command)
+          puts Colorize.green(cmd.process_holder.result.assout) unless dry_run?
+        end
+      end
+    end
+
+    # @api private
+    # Root of all subcommands
+    class Main < Clamp::Command
+      module SubCommands
+        # show-version subcommand
+        class ShowVersion < Abstract::SubCommand
+          include AssLauncher::Enterprise::CliDefsLoader
+
+          def self.command_name
+            'show-version'
+          end
+
+          def self._banner
+            'Show version of ass_launcher gem and'\
+              ' list of known 1C:Enterprise'
+          end
+
+          def known_versions_list
+            " - v#{defs_versions.reverse.map(&:to_s).join("\n - v")}"
+          end
+
+          def execute
+            puts Colorize.yellow('ass_launcher:')\
+              + Colorize.green(" v#{AssLauncher::VERSION}")
+            puts Colorize.yellow('Known 1C:Enterprise:')
+            puts Colorize.green(known_versions_list)
+          end
+        end
+
+        # env subcommand
+        class Env < Abstract::SubCommand
+          include Abstract::Option::SearchPath
+          include AssLauncher::Api
+
+          def self.command_name
+            'env'
+          end
+
+          def self._banner
+            'Show 1C:Enterprise installations'
+          end
+
+          def list(clients)
+            " - v#{clients.map(&:version).sort.reverse.join("\n - v")}"
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          def execute
+            puts Colorize.yellow '1C:Enterprise installations was searching in:'
+            puts Colorize
+              .green " - #{AssLauncher::Enterprise.search_paths.join("\n - ")}"
+            puts Colorize.yellow 'Thick client installations:'
+            puts Colorize.green list(thicks)
+            puts Colorize.yellow 'Thin client installations:'
+            puts Colorize.green list(thins)
+          end
+          # rubocop:enable Metrics/AbcSize
+        end
+      end
+
+      # Main cmd invoker
+      Dir.glob File.join(File.expand_path('../cmd', __FILE__), '*.rb') do |lib|
+        require lib if File.basename(lib) != 'abstract.rb'
+      end
+
+      extend Abstract::SubCommand::Declaration
+
+      declare_subcommands
+    end
+  end
+end