ass_launcher 0.1.1.alpha

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

@@ -0,0 +1,209 @@
+# encoding: utf-8
+
+module AssLauncher
+  module Enterprise
+    module Cli
+      # DSL for describe 1C:Enterprise command-line interface
+      # @api public
+      module SpecDsl
+        require 'ass_launcher/enterprise/cli/spec_dsl/dsl_helpers'
+        require '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)
+        end
+
+        # Describe run modes specifications
+        # @param mode [Symbol] 1C:Enterprise run mode.
+        # @param desc [String] description for run mode
+        # @param banner [String] bunner for usage
+        def describe_mode(mode, desc, banner)
+          fail "Undefined mode: #{mode}" unless defined_modes.include? mode
+          described_modes[mode] = { desc: _t(desc), banner: _t(banner) }
+        end
+
+        # Define CLI parameters group
+        # @param name [Symbol] group name
+        # @param desc [String] description for group
+        # @param priority [Fixnum] priority for parameters group for build
+        #  help message
+        def define_group(name, desc, priority)
+          parameters_groups[name.to_sym] =
+            { 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)
+        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)
+        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)
+        end
+
+        # Block to define CLI parameters for run modes
+        # @param modes [Array<Symbol>] run modes wich CLI parameters defined
+        # @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?
+          self.current_modes = modes
+          instance_eval(&block)
+        end
+
+        # Block to grouping CLI parameters into parameters group.
+        # Group must be defined as {#define_group}
+        # @param key [Symbol] group name
+        # @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?
+          self.current_group = key
+          instance_eval(&block)
+        end
+
+        # 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
+        #  description for help message
+        def switch_list(**options)
+          options.each_key do |k|
+            options[k] = _t(options[k])
+          end
+        end
+        alias_method :chose_list, :switch_list
+
+        # Define {Cli::Parameters::Path} parameter and him subparameters.
+        # Subparameters defines in the block.
+        # @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 options (see Cli::Parameters::StringParam#initialize)
+        # @return [Cli::Parameters::Path]
+        def path(name, desc, binary_matcher = nil, **options, &block)
+          new_param(Parameters::Path, name, desc,
+                    binary_matcher, **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)
+          new_param(Parameters::StringParam, name, desc,
+                    binary_matcher, **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)
+          new_param(Parameters::Flag, name, desc,
+                    binary_matcher, **options, &block)
+        end
+
+        # Define {Cli::Parameters::Switch} parameter and him subparameters.
+        # Subparameters defines in the block.
+        # @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)
+          new_param(Parameters::Switch, name, desc,
+                    binary_matcher, **options, &block)
+        end
+
+        # Define {Cli::Parameters::Chose} parameter and him subparameters.
+        # Subparameters defines in the block.
+        # @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)
+          new_param(Parameters::Chose, name, desc,
+                    binary_matcher, **options, &block)
+        end
+
+        # Define {Cli::Parameters::StringParam} parameter suitable for
+        # validation URL argument. Subparameters defines in the block.
+        # @note It initialize +:value_validator+ option with +Proc+
+        # @param (see #path)
+        # @return [Cli::Parameters::StringParam]
+        def url(name, desc, binary_matcher = nil, **options, &block)
+          options[:value_validator] = url_value_validator(name)
+          string(name, desc, binary_matcher, **options, &block)
+        end
+
+        def url_value_validator(n)
+          proc do |value|
+            begin
+              URI(value)
+            rescue
+              raise ArgumentError,
+                    "Invalid URL for parameter `#{n}': `#{value}'"
+            end
+            value
+          end
+        end
+        private :url_value_validator
+
+        # Define {Cli::Parameters::StringParam} parameter suitable for
+        # validation numeric argument. Subparameters defines in the block.
+        # @note It initialize +:value_validator+ option with +Proc+
+        # @param (see #path)
+        # @return [Cli::Parameters::StringParam]
+        def num(name, desc, binary_matcher = nil, **options, &block)
+          options[:value_validator] = num_value_validator(name)
+          string(name, desc, binary_matcher, **options, &block)
+        end
+
+        def num_value_validator(n)
+          proc do |value|
+            begin
+              Float(value)
+            rescue
+              raise ArgumentError,
+                    "Invalid Number for parameter `#{n}': `#{value}'"
+            end
+            value
+          end
+        end
+        private :num_value_validator
+
+        # 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
+        end
+      end # SpecDsl
+    end
+  end
+end

data/lib/ass_launcher/enterprise/cli.rb

@@ -0,0 +1,131 @@
+# 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
+    module Cli
+      require 'ass_launcher/enterprise/cli/arguments_builder'
+      require 'ass_launcher/enterprise/cli/parameters'
+      require 'ass_launcher/enterprise/cli/spec_dsl'
+
+      # Run modes defined for 1C Enterprise binary client
+      DEFINED_MODES = [
+        :createinfobase,
+        :enterprise,
+        :designer
+      ].freeze
+
+      # Return suitable run_mode see {DEFINED_MODES} for
+      # 1c client
+      # @param cl [BinaryWrapper::ThinClient, BinaryWrapper::ThickClient]
+      # @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
+      end
+
+      # Load and 1C Enterprise cli specifications
+      # for buld cli api and cli api help
+      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
+
+        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
+        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)
+        end
+
+        def usage(run_mode = nil)
+          raise NotImplementedError
+        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
+        end
+
+        def match?(binary_wrapper)
+          match_client?(binary_wrapper) && match_version?(binary_wrapper)
+        end
+
+        private
+        def match_client?(bw)
+          return true if client == :all
+          client == bw.class.name.split('::').last.
+            to_s.downcase.gsub(/client$/,'').to_sym
+        end
+
+        def match_version?(bw)
+          requirement.satisfied_by? bw.version
+        end
+      end
+    end
+  end
+end

data/lib/ass_launcher/enterprise/ole/ole_binaries.rb

@@ -0,0 +1,249 @@
+# encoding: utf-8
+require 'ass_launcher/enterprise/ole/win32ole'
+#
+module AssLauncher
+  #
+  module Enterprise
+    #
+    module Ole
+      # Wrappers fore 1C Enterprise OLE servers
+      module OleBinaries
+        # @abstract
+        class AbstractAssOleBinary
+          include AssLauncher::Support::Platforms
+          # @return [Gem::Version::Requirement]
+          attr_reader :requirement
+          # @param requirement [Gem::Version::Requirement] version of 1C Ole
+          #  server
+          def initialize(requirement)
+            fail NotImplementedError, 'WIN32OLE undefined for this machine'\
+              if linux?
+            @requirement = Gem::Version::Requirement.new(requirement)
+          end
+
+          # @return [WIN32OLE] 1C Ole server object
+          def ole
+            @ole ||= new_ole
+          end
+
+          def new_ole
+            reg
+            WIN32OLE.new(prog_id)
+          end
+          private :new_ole
+
+          def v8x
+            instaled_version.to_s.split('.').slice(0, 2).join('')
+          end
+          private :v8x
+
+          def instaled_version
+            return binary_wrapper.version if binary_wrapper
+          end
+          alias_method :version, :instaled_version
+
+          # @return [AssLauncher::Enterprise::BinaryWrapper]
+          def binary_wrapper
+            @binary_wrapper ||= _binary_wrapper
+          end
+          protected :binary_wrapper
+
+          def _binary_wrapper
+            fail 'Abstract method call'
+          end
+          private :_binary_wrapper
+
+          def registred_version
+            fail NotImplementedError # FIXME: not find object in WinReg
+          end
+          private :registred_version
+
+          # Return +true+ if 1C Ole object instaled
+          def instaled?
+            return false unless version
+            requirement.satisfied_by?(version) && File.file?(path.to_s)
+          end
+
+          def registred?
+            # FIXME: always return false and not find object in WinReg
+            # registred_version == version
+            false # FIXME
+          end
+          private :registred?
+
+          # Register Ole server
+          def reg
+            return true if registred?
+            fail "Platform version `#{requirement}' not instaled."\
+              unless instaled?
+            reg_server
+          end
+
+          def reg_server
+            fail 'Abstract method call'
+          end
+          private :reg_server
+
+          # Unregister Ole server
+          def unreg
+            return true unless registred?
+            fail "Platform version `#{requirement}' not instaled."\
+              unless instaled?
+            unreg_server
+          end
+
+          def unreg_server
+            fail 'Abstract method call'
+          end
+          private :unreg_server
+
+          def path
+            @path ||= _path
+          end
+          protected :path
+
+          def binary
+            fail 'Abstract method call'
+          end
+          protected :binary
+
+          def _path
+            return unless binary_wrapper
+            platform.path(File.join(binary_wrapper.path.dirname.to_s, binary))
+          end
+          private :_path
+
+          def clsid
+            clsids[v8x]
+          end
+          protected :clsid
+
+          def clsids
+            fail 'Abstract method call'
+          end
+          protected :clsids
+        end
+
+        # Wrapper for v8x.COMConnector inproc OLE server
+        # @note It work not correct. If old version ole object is loded in
+        # memory new registred version will be ignored.
+        class COMConnector < AbstractAssOleBinary
+          require 'english'
+          BINARY = 'comcntr.dll'
+          def binary
+            BINARY
+          end
+          private :binary
+
+          def prog_id
+            "v#{v8x}.COMConnector"
+          end
+          private :prog_id
+
+          def clsids
+            { '83' => '{181E893D-73A4-4722-B61D-D604B3D67D47}',
+              '82' => '{2B0C1632-A199-4350-AA2D-2AEE3D2D573A}',
+              '81' => '{48EE4DBA-DE11-4af2-83B9-1F7FD6B6B3E3}'
+            }
+          end
+          private :clsids
+
+          def _binary_wrapper
+            Enterprise.thick_clients(requirement.to_s).last
+          end
+          private :_binary_wrapper
+
+          # @note It work not correct. If old version ole object is loded in
+          # memory new registred version will be ignored.
+          def reg_server
+            fail_reg_unreg_server('register', reg_unreg_server('i'))
+          end
+          private :reg_server
+
+          def unreg_server
+            fail_reg_unreg_server('unregister', reg_unreg_server('u'))
+          end
+          private :unreg_server
+
+          def reg_unreg_server(mode)
+            `regsvr32 /#{mode} /s "#{path.win_string}"`
+            childe_status
+          end
+          private :reg_unreg_server
+
+          def childe_status
+            $CHILD_STATUS
+          end
+          private :childe_status
+
+          def fail_reg_unreg_server(message, status)
+            fail "Failure #{message} `#{path.win_string}' #{status}"\
+              unless status.success?
+            status
+          end
+          private :fail_reg_unreg_server
+        end
+
+        # Wrapper for v8x.Application standalone OLE server
+        class ThickApplication < AbstractAssOleBinary
+          BINARY = '1cv8.exe'
+          def binary
+            BINARY
+          end
+          private :binary
+
+          def prog_id
+            "v#{v8x}.Application"
+          end
+          private :prog_id
+
+          def _binary_wrapper
+            Enterprise.thick_clients(requirement.to_s).last
+          end
+          private :_binary_wrapper
+
+          def reg_server
+            run_as_enterprise ['/regserver']
+          end
+          private :reg_server
+
+          def unreg_server
+            run_as_enterprise ['/unregserver']
+          end
+          private :unreg_server
+
+          def run_as_enterprise(args)
+            binary_wrapper.command(:enterprise, args)
+              .run.wait.result.verify!
+          end
+          private :run_as_enterprise
+        end
+
+        # Wrapper for v8xc.Application standalone OLE server
+        class ThinApplication < ThickApplication
+          BINARY = '1cv8c.exe'
+          def binary
+            BINARY
+          end
+          private :binary
+
+          def prog_id
+            "v#{v8x}c.Application"
+          end
+          private :prog_id
+
+          def _binary_wrapper
+            Enterprise.thin_clients(requirement.to_s).last
+          end
+          private :_binary_wrapper
+
+          def run_as_enterprise(args)
+            binary_wrapper.command(args)
+              .run.wait.result.verify!
+          end
+          private :run_as_enterprise
+        end
+      end
+    end
+  end
+end

data/lib/ass_launcher/enterprise/ole/win32ole.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+# Monkey patch for WIN32OLE class
+# - Define dummy class for Linux. Fail +NotImplementedError+ in constructor.
+#
+# - Patch for have chanse to close connection with 1C infobase in class
+#   {AssLauncher::Enterprise::Ole::IbConnection IBConnector}. For this reason
+#   overload
+#   method +WIN32OLE#method_missing+ and hold Ole object refs retuned from ole
+#   method into {#__objects__} array.
+#   {AssLauncher::Enterprise::Ole::IbConnection IBConnector}
+#   when close connection call
+#   {#\_\_ass_ole_free\_\_} and try to ole_free for all in {#__objects__} array.
+# @see AssLauncher::Enterprise::Ole::IbConnection#__close__
+class WIN32OLE
+  # :nocov:
+  if AssLauncher::Support::Platforms.linux?
+    def initialize(*_)
+      fail NotImplementedError, 'WIN32OLE undefined for this machine'
+    end
+
+    # For tests
+    def method_missing(*args)
+      args[1]
+    end
+  else
+    require 'win32ole'
+    @win32ole_loaded = true # for tests zonde
+  end
+  # :nocov:
+
+  # Hold created Ole objects
+  # @return [Array]
+  # @api private
+  def __objects__
+    @__objects__ ||= []
+  end
+
+  # @note WIN32OLE avtomaticaly wrapp Ruby objects into WIN32OLE class
+  #  when they passed as parameter.
+  #  When passed object retuns on Ruby side he will keep as WIN32OLE
+  #
+  # True if real object is Ruby object
+  def __ruby__?
+    ole_respond_to? :object_id
+  end
+
+  # @note (see #__ruby__?)
+  # Return Ruby object wrapped in to WIN32OLE. If {#__ruby__?} is *false*
+  # return *self*
+  # @return [Object, self]
+  def __real_obj__
+    return self unless __ruby__?
+    ObjectSpace._id2ref(invoke :object_id)
+  end
+
+  # @api private
+  # Call ole_free for all created chiled Ole objects then free self
+  def __ass_ole_free__
+    @__objects__ = __ass_ole_free_objects__
+    self.class.__ass_ole_free__(self)
+  end
+
+  # Free created chiled Ole objects
+  def __ass_ole_free_objects__
+    __objects__.each do |o|
+      o.send :__ass_ole_free__ if o.is_a? WIN32OLE
+    end
+    nil
+  end
+  private :__ass_ole_free_objects__
+
+  # @api private
+  # Try call ole_free for ole object
+  # @param obj [WIN32OLE] object for free
+  def self.__ass_ole_free__(obj)
+    return if WIN32OLE.ole_reference_count(obj) <= 0
+    obj.ole_free
+  end
+
+  # @!method method_missing(*args)
+  # overload {WIN32OLE#method_missing} and hold Ole object into
+  # {#__objects__} array if called Ole method return Ole object
+  old_method_missing = instance_method(:method_missing)
+  define_method(:method_missing) do |*args|
+    # :nocov:
+    o = old_method_missing.bind(self).call(*args)
+    __objects__ << o if o.is_a? WIN32OLE
+    o
+    # :nocov:
+  end
+end