ass_launcher 0.1.1.alpha → 0.2.0

data/lib/ass_launcher/enterprise/cli/spec_dsl/dsl_helpers.rb

@@ -25,7 +25,7 @@ module AssLauncher
           end
 
           def parameters
-            @parameters ||= Parameters::ParametersList.new
+            @parameters ||= Parameters::AllParameters.new
           end
 
           attr_accessor :current_modes
@@ -44,21 +44,127 @@ module AssLauncher
           end
           private :current_parent
 
-          def new_param(klass, name, desc, binary_matcher, **options, &block)
-            p = klass.new(name, desc, binary_matcher, current_group,
+          def new_param(klass, name, desc, clients = [], options = {}, &block)
+            fail 'Group must be specifed' if current_group.nil?
+            fail 'Modes must be specifed' if current_modes.nil?
+            p = klass.new(name, desc,
+                          new_binary_matcher(clients),
+                          current_group,
                           current_modes, current_parent, **options)
-            return unless p.match?(binary_wrapper, run_mode)
-            parameters << p
+            add_parameter(p)
             eval_sub_params(p, &block) if block_given?
           end
           private :new_param
 
+          def new_binary_matcher(clients)
+            return (inherid_binary_matcher || auto_binary_matcher) if\
+              clients.size == 0
+            BinaryMatcher.new(clients, from_current_version)
+          end
+          private :new_binary_matcher
+
+          def auto_binary_matcher
+            BinaryMatcher.auto(current_modes, from_current_version)
+          end
+          private :auto_binary_matcher
+
+          def inherid_binary_matcher
+            BinaryMatcher.new(current_parent.binary_matcher.clients,
+                              from_current_version) if current_parent
+          end
+          private :inherid_binary_matcher
+
+          def change_param(name, &block)
+            p = get_parameter(name)
+            old_g = current_group
+            old_m = current_modes
+            self.current_group = p.group
+            self.current_modes = p.modes
+            eval_sub_params(p, &block) if block_given?
+            self.current_group = old_g
+            self.current_modes = old_m
+          end
+          private :change_param
+
+          def get_parameter(name)
+            p = parameters.find_for_version(name,
+                                            current_parent,
+                                            current_version)
+            fail "Parameter #{name} not found for #{current_version}." unless p
+            p
+          end
+          private :get_parameter
+
+          def add_parameter(p)
+            parameters.add p, current_version
+          end
+          private :add_parameter
+
+          # @return [nil]
+          def restrict_params(name, v)
+            get_parameters(name).each do |p|
+              p.restrict_from(v)
+            end
+            nil
+          end
+          private :restrict_params
+
+          def get_parameters(name)
+            p = parameters.find(name, current_parent)
+            fail "Parameter #{name} not found." if p.size == 0
+            p
+          end
+          private :get_parameters
+
           def eval_sub_params(p, &block)
             parents_stack.unshift p
             instance_eval(&block)
             parents_stack.shift
           end
           private :eval_sub_params
+
+          def enterprise_versions
+            @enterprise_versions ||= []
+          end
+
+          def add_enterprise_versions(v)
+            fail ArgumentError, 'Invalid version sequences. Expects version >'\
+              " #{current_version} but given #{v}" unless v > current_version
+            enterprise_versions << v
+          end
+          private :add_enterprise_versions
+
+          def reset_all
+            reset_group
+            reset_modes
+          end
+          private :reset_all
+
+          def reset_group
+            self.current_group = nil
+          end
+          private :reset_group
+
+          def reset_modes
+            self.current_modes = nil
+          end
+          private :reset_modes
+
+          def current_version
+            return Gem::Version.new('0') if enterprise_versions.last.nil?
+            enterprise_versions.last
+          end
+          private :current_version
+
+          def from_current_version
+            from_version current_version
+          end
+          private :from_current_version
+
+          def from_version(v)
+            Gem::Version::Requirement.new ">= #{v}"
+          end
+          private :from_version
         end
       end
     end

data/lib/ass_launcher/enterprise/cli/spec_dsl.rb

@@ -7,13 +7,14 @@ module AssLauncher
       # @api public
       module SpecDsl
         require 'ass_launcher/enterprise/cli/spec_dsl/dsl_helpers'
-        require 'uri'
+        require 'addressable/uri'
         include DslHelpers
 
         # Define 1C:Enterprise version for defined CLI specifications
         # @param v [String] 1C:Enterprise verion string
-        def enterprise_version(v = '0')
-          @enterprise_version ||= Gem::Version.new(v)
+        def enterprise_version(v)
+          reset_all
+          add_enterprise_versions Gem::Version.new(v)
         end
 
         # Describe run modes specifications
@@ -35,28 +36,23 @@ module AssLauncher
             { desc: _t(desc), priority: priority }
         end
 
-        # Binary matcher for 1C:Enterprise thick client for which CLI parameter
-        # defined
-        # @param v [String] version of 1C:Enterprise client
-        # @return [Cli::BinaryMatcher]
-        def thick_client(v = '>= 0')
-          BinaryMatcher.new(:thick, v)
+
+        # Return 1C client identifier see {BinaryMatcher::ALL_CLIENTS}
+        # @return [Symbol] :thick
+        def thick
+          :thick
         end
 
-        # Binary matcher for 1C:Enterprise thin client for which CLI parameter
-        # defined
-        # @param (see #thick_client)
-        # @return (see #thick_client)
-        def thin_client(v = '>= 0')
-          BinaryMatcher.new(:thin, v)
+        # Return 1C client identifier see {BinaryMatcher::ALL_CLIENTS}
+        # @return [Symbol] :thin
+        def thin
+          :thin
         end
 
-        # Binary matcher for 1C:Enterprise thin and thick clients for
-        # which CLI parameter defined
-        # @param (see #thick_client)
-        # @return (see #thick_client)
-        def all_client(v = '>= 0')
-          BinaryMatcher.new(:all, v)
+        # Return 1C client identifier see {BinaryMatcher::ALL_CLIENTS}
+        # @return [Symbol] :web
+        def web
+          :web
         end
 
         # Block to define CLI parameters for run modes
@@ -64,11 +60,17 @@ module AssLauncher
         # @raise if passed invalid 1C:Enterprise run mode
         # @raise if call without block
         def mode(*modes, &block)
-          fail "Undefined modes #{modes}" if (defined_modes & modes).size == 0
-          fail 'method `mode` block required' unless block_given?
+          fail_if_wrong_modes modes
+          fail 'Block required' unless block_given?
           self.current_modes = modes
           instance_eval(&block)
+          reset_modes
+        end
+
+        def fail_if_wrong_modes(modes)
+          fail "Undefined modes #{modes}" if (defined_modes & modes).size == 0
         end
+        private :fail_if_wrong_modes
 
         # Block to grouping CLI parameters into parameters group.
         # Group must be defined as {#define_group}
@@ -76,13 +78,19 @@ module AssLauncher
         # @raise if passed undefined group
         # @raise if call without block
         def group(key, &block)
-          fail "Undefined parameters group #{key}"\
-            unless parameters_groups.key? key
-          fail 'method `group` block required' unless block_given?
+          fail_if_wrong_group(key)
+          fail 'Block required' unless block_given?
           self.current_group = key
           instance_eval(&block)
+          reset_group
         end
 
+        def fail_if_wrong_group(key)
+          fail "Undefined parameters group #{key}" unless parameters_groups
+            .key? key
+        end
+        private :fail_if_wrong_group
+
         # Build switch or chose list for CLI parameters clases:
         # {Cli::Parameters::Switch} or {Cli::Parameters::Chose}
         # @param options [Hash] +:key+ is argument for CLI parameter, +value+ is
@@ -99,33 +107,57 @@ module AssLauncher
         # @param name [String] name of 1C:Enterprise CLI parameter
         # @param desc [String] description of 1C:Enterprise CLI parameter for
         #   build help message
-        # @param binary_matcher [Cli::BinaryMatcher] uses DSL:
-        #  {#thick_client}, {#thin_client} or {#all_client}. If +nil+ uses
-        #  {Cli::BinaryMatcher} for all 1C clients and all client's
-        #  verions like returns {#all_client} method
+        # @param clients [Array] uses DSL:
+        #  {#thick}, {#thin} or {#web}. On default uses
+        #  array for all 1C clients {BinaryMatcher::ALL_CLIENTS}
         # @param options (see Cli::Parameters::StringParam#initialize)
         # @return [Cli::Parameters::Path]
-        def path(name, desc, binary_matcher = nil, **options, &block)
+        def path(name, desc, *clients, **options, &block)
           new_param(Parameters::Path, name, desc,
-                    binary_matcher, **options, &block)
+                    clients, **options, &block)
+        end
+
+        # Path with exist validation.
+        # @see #path
+        # @param (see #path)
+        # @return (see #path)
+        def path_exist(name, desc, *clients, **options, &block)
+          path(name, desc, *clients, options.merge(must_be: :exist),
+               &block)
+        end
+
+        # Path with not exist validation.
+        # @see #path
+        # @param (see #path)
+        # @return (see #path)
+        def path_not_exist(name, desc, *clients, **options, &block)
+          path(name, desc, *clients,
+               options.merge(must_be: :not_exist),
+               &block)
+        end
+
+        # @return [Cli::Parameters::PathTwice]
+        def path_twice(name, desc, *clients, **options, &block)
+          new_param(Parameters::PathTwice, name, desc,
+                    clients, **options, &block)
         end
 
         # Define {Cli::Parameters::StringParam} parameter and him subparameters.
         # Subparameters defines in the block.
         # @param (see #path)
         # @return [Cli::Parameters::StringParam]
-        def string(name, desc, binary_matcher = nil, **options, &block)
+        def string(name, desc, *clients, **options, &block)
           new_param(Parameters::StringParam, name, desc,
-                    binary_matcher, **options, &block)
+                    clients, **options, &block)
         end
 
         # Define {Cli::Parameters::Flag} parameter and him subparameters.
         # Subparameters defines in the block.
         # @param (see #path)
         # @return [Cli::Parameters::Flag]
-        def flag(name, desc, binary_matcher = nil, **options, &block)
+        def flag(name, desc, *clients, **options, &block)
           new_param(Parameters::Flag, name, desc,
-                    binary_matcher, **options, &block)
+                    clients, **options, &block)
         end
 
         # Define {Cli::Parameters::Switch} parameter and him subparameters.
@@ -133,9 +165,9 @@ module AssLauncher
         # @note use helper {#switch_list} for build +:switch_list+ option
         # @param (see #path)
         # @return [Cli::Parameters::Switch]
-        def switch(name, desc, binary_matcher = nil, **options, &block)
+        def switch(name, desc, *clients, **options, &block)
           new_param(Parameters::Switch, name, desc,
-                    binary_matcher, **options, &block)
+                    clients, options, &block)
         end
 
         # Define {Cli::Parameters::Chose} parameter and him subparameters.
@@ -143,9 +175,9 @@ module AssLauncher
         # @note use helper {#chose_list} for build +:chose_list+ option
         # @param (see #path)
         # @return [Cli::Parameters::Chose]
-        def chose(name, desc, binary_matcher = nil, **options, &block)
+        def chose(name, desc, *clients, **options, &block)
           new_param(Parameters::Chose, name, desc,
-                    binary_matcher, **options, &block)
+                    clients, options, &block)
         end
 
         # Define {Cli::Parameters::StringParam} parameter suitable for
@@ -153,18 +185,19 @@ module AssLauncher
         # @note It initialize +:value_validator+ option with +Proc+
         # @param (see #path)
         # @return [Cli::Parameters::StringParam]
-        def url(name, desc, binary_matcher = nil, **options, &block)
+        def url(name, desc, *clients, **options, &block)
           options[:value_validator] = url_value_validator(name)
-          string(name, desc, binary_matcher, **options, &block)
+          string(name, desc, *clients, **options, &block)
         end
 
         def url_value_validator(n)
           proc do |value|
             begin
-              URI(value)
-            rescue
+              uri = Addressable::URI.parse(value)
+              fail 'Host is nil' if uri.host.nil?
+            rescue Exception => e
               raise ArgumentError,
-                    "Invalid URL for parameter `#{n}': `#{value}'"
+                "Invalid URL for parameter `#{n}': `#{value}' #{e.message}"
             end
             value
           end
@@ -176,9 +209,9 @@ module AssLauncher
         # @note It initialize +:value_validator+ option with +Proc+
         # @param (see #path)
         # @return [Cli::Parameters::StringParam]
-        def num(name, desc, binary_matcher = nil, **options, &block)
+        def num(name, desc, *clients, **options, &block)
           options[:value_validator] = num_value_validator(name)
-          string(name, desc, binary_matcher, **options, &block)
+          string(name, desc, *clients, **options, &block)
         end
 
         def num_value_validator(n)
@@ -194,14 +227,32 @@ module AssLauncher
         end
         private :num_value_validator
 
+        # Restrict already specified parameter +name+
+        # recursively with all subparameters
+        # @param name (see #path)
+        # @return (see DslHelpers#restrict_params)
+        def restrict(name)
+          restrict_params(name, current_version)
+        end
+
+        # Change specifications of subparameters for already
+        # specified parameter +name+
+        def change(name, &block)
+          change_param name, &block
+        end
+
         # Stub for skipped parameter. Many 1C:Enterprise CLI parameters is not
         # imprtant for describe in {Cli::CliSpec}. For define it fact, you can
         # use this method.
-        # @todo may be registring skipped parameter for worning?
         # @param (see #path)
-        # @return [nil]
-        def skip(name, desc = '', binary_matcher = nil, **options, &block)
-          # nop
+        # @return [Cli::Parameters::Skip]
+        def skip(name, desc = '')
+          p = Parameters::Skip.new(name, desc,
+                                   new_binary_matcher([:skip]),
+                                   :skip,
+                                   [:skip], current_parent)
+          add_parameter p
+          p
         end
       end # SpecDsl
     end

data/lib/ass_launcher/enterprise/cli.rb

@@ -1,12 +1,6 @@
 # encoding: utf-8
 
 module AssLauncher
-  class Configuration
-    # 1C Enterprise cli specifications text written on Cli::SpecDsl
-    def platform_cli_spec
-      @platform_cli_spec ||= Enterprise::Cli::CliSpec.load
-    end
-  end
   module Enterprise
     # @api private
     # 1C:Enterprise cli api wrapper
@@ -14,117 +8,83 @@ module AssLauncher
       require 'ass_launcher/enterprise/cli/arguments_builder'
       require 'ass_launcher/enterprise/cli/parameters'
       require 'ass_launcher/enterprise/cli/spec_dsl'
+      require 'ass_launcher/enterprise/cli/binary_matcher'
 
-      # Run modes defined for 1C Enterprise binary client
+      # Run modes defined for 1C Enterprise clients
       DEFINED_MODES = [
         :createinfobase,
         :enterprise,
-        :designer
+        :designer,
+        :webclient
       ].freeze
 
       # Return suitable run_mode see {DEFINED_MODES} for
       # 1c client
-      # @param cl [BinaryWrapper::ThinClient, BinaryWrapper::ThickClient]
+      # @param klass [BinaryWrapper::ThinClient, BinaryWrapper::ThickClient,
+      #  WebClient]
       # @return [Array<Symbol>]
-      def self.defined_modes_for(cl)
-        return [DEFINED_MODES[1]] if cl.instance_of? BinaryWrapper::ThinClient
-        return DEFINED_MODES if cl.instance_of? BinaryWrapper::ThickClient
+      def self.defined_modes_for(klass)
+        return [DEFINED_MODES[1]] if klass == BinaryWrapper::ThinClient
+        return DEFINED_MODES - [:webclient]\
+          if klass == BinaryWrapper::ThickClient
+        return [DEFINED_MODES.last] if klass == WebClient
       end
 
-      # Load and 1C Enterprise cli specifications
-      # for buld cli api and cli api help
+      # 1C Enterprise cli specifications
+      # for {BinaryWrapper::ThinClient}, {BinaryWrapper::ThickClient}
+      # or for {WebClient}
+      # @api public
       class CliSpec
-        def self.loader(binary, run_mode)
-          Class.new do
-            include AssLauncher::Enterprise::Cli::SpecDsl
-            attr_reader :run_mode, :binary_wrapper
-            def initialize(binary_wrapper, run_mode)
-              @binary_wrapper = binary_wrapper
-              @run_mode = run_mode
-            end
-          end.new(binary, run_mode)
-        end
-        private_class_method :loader
-
-        # @api private
-        # @todo In future, may be, should extract +cli.spec+ and use
-        #  configurable +cli.spec+ path
-        def self.load
-          spec = File.read(File.expand_path('../cli/cli.spec',__FILE__))
-        end
-
-        # Max 1C Enterprise version
-        # for which defined parameters
-        # @return [Gem::Version]
-        attr_reader :enterprise_version
-        # Defined 1C Enterprise cli parameters
-        # @return [Parameters::ParamtersList]
-        attr_reader :parameters
-        # 1C Enterprise run modes descriptions for build cli api help
-        # @return (see Cli::SpecDsl#described_modes)
-        attr_reader :run_modes
-        # Description for 1C Enterprise cli parameters group for group
-        #  parameters in cli help
-        # @return (see Cli::SpecDsl#described_modes)
-        attr_reader :groups
 
-        attr_reader :current_run_mode
+        # see +binary_wrapper+ parameter for {#initialize}
+        attr_reader :binary_wrapper
+        alias_method :current_binary_wrapper, :binary_wrapper
 
-        attr_reader :current_binary_wrapper
-
-        # @api private
-        def initialize(parameters, modes, groups,
-                       enterprise_version, binary_wrapper, run_mode)
-          @run_modes = modes.select { |k, v| binary_wrapper.run_modes.include? k }
-          @groups = groups
-          @enterprise_version = enterprise_version
-          @current_run_mode = run_mode
-          @current_binary_wrapper = binary_wrapper
-          @parameters = parameters
+        # @param binary_wrapper
+        #  (see Cli::Parameters::AllParameters#to_parameters_list)
+        def initialize(binary_wrapper)
+          @binary_wrapper = binary_wrapper
         end
 
-        # Build suitable cli specifications for 1C Enterprise binary type,
-        # version and run mode
-        # @param binary [BinaryWrapper::ThinClient, BinaryWrapper::ThickClient]
-        # @param run_mode [Symbol] see {Cli::DEFINED_MODES}
-        def self.for(binary, run_mode)
-          l = loader(binary, run_mode)
-          l.instance_eval(AssLauncher.config.platform_cli_spec)
-          new(l.parameters,
-              l.described_modes,
-              l.parameters_groups,
-              l.enterprise_version,
-              binary,
-              run_mode)
+        # Return parameters specified for
+        # 1C:Enterprise client wrappend into {#binary_wrapper}
+        # for given +run_mode+
+        # @param run_mode (see
+        #  Cli::Parameters::AllParameters#to_parameters_list)
+        # @return [Cli::Parameters::ParametersList]
+        def parameters(run_mode)
+          cli_def.parameters.to_parameters_list(binary_wrapper, run_mode)
         end
 
-        def usage(run_mode = nil)
-          raise NotImplementedError
+        # @return [CliDef]
+        def self.cli_def
+          @cli_def ||= load_cli_def
         end
-      end
 
-      # @api private
-      class BinaryMatcher
-        attr_reader :client, :requirement
-        def initialize(client = :all, version = '>= 0')
-          @client = client.to_sym
-          @requirement = Gem::Requirement.new version
+        # (see .cli_def)
+        def cli_def
+          self.class.cli_def
         end
 
-        def match?(binary_wrapper)
-          match_client?(binary_wrapper) && match_version?(binary_wrapper)
+        def self.load_cli_def
+          require 'ass_launcher/enterprise/cli_def'
+          CliDef
         end
+        private_class_method :load_cli_def
 
-        private
-        def match_client?(bw)
-          return true if client == :all
-          client == bw.class.name.split('::').last.
-            to_s.downcase.gsub(/client$/,'').to_sym
+        # Build suitable cli specifications for 1C Enterprise binary type,
+        # version and run mode
+        # @param (see #initialize)
+        def self.for(binary_wrapper)
+          new(binary_wrapper)
         end
 
-        def match_version?(bw)
-          requirement.satisfied_by? bw.version
+        # :nocov:
+        # @todo Implemets this
+        def usage(run_mode = nil)
+          raise NotImplementedError
         end
+        # :nocov:
       end
     end
   end