ass_launcher 0.1.1.alpha → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a5b8798a403c888bd5947f3edb2030e81f17c68
-  data.tar.gz: 762c0454cbc5b5505b090bc94112c929de13a624
+  metadata.gz: c6b94d52dbe7ef1d1765d781154d6ace91eb0341
+  data.tar.gz: 9869be552aafa7badc2150e4c9e9ad41ccd99bb0
 SHA512:
-  metadata.gz: 9a010b42049e37397630746ec11ec815bde30b4205ded2aeeea658adc37e4de9296cc95a36f915b3269d5c89c40ef0774bfcb8e285860127a200779d2348e1f5
-  data.tar.gz: 5a642317ae14b69c5a8b9c3181eb29ed023a34e636b5e4364a8987ed30fd010b8e70d604fd66625b9522aaf057056377410d2c4aa071c10f94e2c959fe07ce62
+  metadata.gz: 87421d5aad3ed605426ff419c02101cbed5354c45139d961db4a3e0cfc194f4ca6cd544fa48ed5977ad541e3e072a9fcdb100f6ca1ae92c9a622c59ba0c70c95
+  data.tar.gz: 9f40bbfdfd74bbfc56ae5e76f2be176feddb9e19ad245ea9c0b5b0259cac8a141d6f85288ff94a594bc2ffb906c4a4304fd4bbe417987f11003e3180106c7d55

data/README.md

@@ -1,8 +1,18 @@
+
+[![Code Climate](https://codeclimate.com/github/leoniv/ass_launcher/badges/gpa.svg)](https://codeclimate.com/github/leoniv/ass_launcher)
 # AssLauncher
 
-Ruby wrapper for 1C:Enterprise platform. Don't ask why this necessary. Believe this necessary!
+Ruby wrapper for 1C:Enterprise platform.
+
+Goal of this to make easily and friendly writing scripts for development
+and support lifecycle of 1C:Enterprise applications
+
+`AssLauncher` is cross platform but **it full tested in `Cygwin` only!**. In  `Windows` and `Linux` it works too.
+
+In `Linux` don't support `OLE` feature. Don't known why I told it ;)
 
-## Installation
+
+## Quick start
 
 Add this line to your application's Gemfile:
 
@@ -18,97 +28,72 @@ Or install it yourself as:
 
     $ gem install ass_launcher
 
-## Usage
-
-For example:
+For example, writing script which dumping 1C:Enterprise application
 
 ```ruby
 require 'ass_launcher'
 
-include AssLauncher::API
+include AssLauncher::Api
 
-#
-# Get 1C:Enterprise v8.3.7 binary wrapper
-#
+def main(dupm_path)
+  # Get wrapper for the thck client
+  thick_client = thicks('~> 8.3.8.0').last
 
-cl = thick_clients('~> 8.3.7').last
+  # Fail if 1C:Enterprise installation not found
+  fail '1C:Enterprise not found' if thick_client.nil?
 
-raise '1C:Enterprise v8.3.7 not found' if cl.nil?
+  # Build designer command
+  designer = thick_client.command :designer do
+    _S 'enterprse_server/application_name'
+    dumpIB dupm_path
+  end
 
-#
-# create new infobase
-#
+  # Execute command
+  designer.run.wait
 
-conn_str = connection_string 'File="./new.ib"'
+  # Verify result
+  designer.process_holder.result.verify!
+end
 
-ph = cl.command(:createinfobase) do
-  connection_string conn_str
-  _AddInList
-end.run.wait
+main ARGV[0]
+```
 
-raise 'Error while create infobase' if ph.result.success?
+## Usage
 
-#
-# dump infobase
-#
+### Examples
 
-command = cl.command(:designer) do
-  connection_string 'File="./new.ib"'
-  _DumpIB './new.ib.dt'
-end
+For more usage examples see [examples](examples/)
 
-ph = command.run
-ph.wait
+For beginning look at
+[examples/enterprise_running_example.rb](examples/enterprise_running_example.rb)
 
-ph.result.verify! # raised error unless executing success
+All [examples](examples/) executable. For run them require
+1C:Enterprise platform version defined in `Examples::MIN_PLATFORM_VERSION`
 
-#
-# run designer for development
-#
+Run all examples:
 
-ph = cl.command(:designer) do
-  connection_string 'File="./new.ib"'
-end.run
+    $rake run_examples
 
-# .... do in designer
+Or run specified example:
 
-ph.kill # kill designer
+    $rake run_examples TEST=examples/enterprise_running_example.rb
 
-```
+### Troubles
 
-## Releases
+Directory [examples/troubles](examples/troubles) contains examples
+which describe troubles with executing 1C:Enterprise binary.
 
-### 0.1.1.alpha
-  - ```Cli::ArgumentsBuilder``` not implements
-  - ```Cli::CliSpec``` require extracts in standalone ```gem```
-  - ```WebClients``` not implements
-  - ```API``` not implements
-  - ```Support::``` stable
-  - ```Enterprse``` stable
-  - ```BinaryWrapper``` mostly stable, depends ```Cli::ArgumentsBuilder```
-  - ```Enterprse::Ole``` stable
+All [examples/troubles](examples/troubles) are executable too.
 
-#### Small exaple:
+Run all troubles:
 
-```ruby
-require 'ass_launcher'
-cs = AssLauncher::Support::ConnectionString.new('File="tmp/tmp.i";Usr="root"')
-tc = AssLauncher::Enterprise.thick_clients('~> 8.3').last
-cmd = tc.command :designer, cs.to_args
-cmd.run # Opens 1C Designer
+    $rake run_trouble_examples
 
-com_conn = AssLauncher::Enterprise::Ole::IbConnection.new '~>8.3'
-com_conn.__open__ cs # Open ole connection into infobase
+**Be careful to run [examples/troubles](examples/troubles)! Learn sources before run it.**
 
-a = com_conn.newObject 'array'
-a.add 'Hello World'
+## Help
 
-puts com_con.string a.get(0) # => "Hello World"
-
-com_con.__close__
-
-cmd.process_holder.kill # Not forget to kill 1C Designer process!
-```
+If you have any questions open issue with `question` lable
 
 ## Development
 
@@ -116,7 +101,24 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+### Development helper
+
+`AssLauncher` include [bin/dev-helper](bin/dev-helper) utility for contributors.
+
+    $bin/dev-helper --help
+
+### Testing
+
+#### Run unit tests:
+
+    $export SIMPLECOV=YES && rake test
+
+Unit tests is isolated and doesn't require installation of 1C:Enterprise
+
+#### Run examples:
+
+Examples writed as `Minitest::Spec`. About run examples see above
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/leoniv/ass_launcher.
-

data/Rakefile

@@ -7,4 +7,23 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
+Rake::TestTask.new(:run_examples) do |t|
+  exec_ole = RbConfig::CONFIG['host_os'].downcase =~ %r{mingw|mswin|cygwin}
+  t.libs << 'examples'
+  t.libs << 'lib'
+  examples = FileList['examples/**/*_example.rb']
+  if exec_ole
+    t.test_files = examples - examples.grep(%r{troubles/}i)
+  else
+    t.test_files = examples - examples.grep(%r{troubles/|enterprise_ole_example}i)
+  end
+end
+
+Rake::TestTask.new(:run_trouble_examples) do |t|
+  t.libs << 'examples'
+  t.libs << 'lib'
+  examples = FileList['examples/**/*_example.rb']
+  t.test_files = examples.grep(%r{trouble}i)
+end
+
 task :default => :test

data/ass_launcher.gemspec

@@ -19,14 +19,20 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.license       = 'MIT'
 
+  spec.required_ruby_version = '~> 2.0'
+
+  spec.metadata      = {'known_enterprise_versions' => AssLauncher::KNOWN_ENTERPRISE_VERSIONS.get.join(', ')}
+
   spec.add_dependency "inifile"
-  spec.add_dependency "ffi"
   spec.add_dependency "methadone"
+  spec.add_dependency "addressable", "= 2.4.0"
 
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "mocha"
+  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/dev-helper

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ass_launcher'
+require_relative './lib/dev_helper'
+
+DevHelper::Cmd::Main.run

data/bin/lib/dev_helper/cli_def_report.rb

@@ -0,0 +1,191 @@
+module DevHelper
+  class CliDefReport
+    module Cmd
+      require 'clamp'
+      class AbstractCommand < Clamp::Command
+        option ['-v', '--version'], 'VERSION',
+          'specific 1C:Enterprise version'
+      end
+
+      class Report < AbstractCommand
+        option '--clients', 'CLIENTS ...', 'specific clients' do |s|
+          s.split.map(&:to_sym).map(&:downcase)
+        end
+
+        option '--modes', 'MODES ...', 'specific run modes' do |s|
+          s.split.map(&:to_sym).map(&:downcase)
+        end
+
+        option ['-c', '--columns'], 'COLUMNS ...',
+          'specific report columns' do |s|
+          s.split.map(&:to_sym).map(&:downcase)
+        end
+
+        option ['-a', '--show-appiared-only'], :flag,
+          'show parameters which appiared in --version only'
+
+        option ['-s', '--skipped-only'], :flag,
+          'show skipped parameters'
+
+        def execute
+          $stdout.puts DevHelper::CliDefReport
+            .for(version, clients: clients, modes: modes,
+                 appiared_only: show_appiared_only?,
+                 skipped_only: skipped_only?).to_csv(columns)
+        rescue ArgumentError => e
+          signal_usage_error e.message
+        end
+      end
+    end
+
+    COLUMS = [:full_name, :parameter, :klass, :parent, :group, :modes,
+              :clients, :requirement, :have_value_validator,
+              :have_switch_value, :accepted_values,  :desc]
+    class ParamReport
+      CliDefReport::COLUMS.each do |col|
+        attr_accessor col
+      end
+
+      def initialize
+        yield self
+      end
+
+      def to_csv(columns)
+        r = ''
+        columns.each do |col|
+          r << "\"#{self.send(col).to_s.gsub('"','\'')}\";"
+        end
+        r.gsub(/;$/,'')
+      end
+    end
+
+    def self.for(version = nil, **filter)
+      new(version, **filter).execute
+    end
+
+    DEF_FILER = {clients: nil,
+                 modes: nil,
+                 skipped_only: false,
+                 appiared_only: nil}
+
+    include DevHelper::CliDefValidator
+
+    attr_reader :version
+    def initialize(version = nil, **filter)
+      @version = version
+      @filter = DEF_FILER.merge filter
+      validate_modes
+      validate_clients
+    end
+
+    def version
+      Gem::Version.new(@version.to_s) if @version
+    end
+
+    def filter(name)
+      @filter[name] || instance_eval("valid_#{name}")
+    end
+
+    def skipped_only?
+      @filter[:skipped_only]
+    end
+
+    def appiared_only
+      @filter[:appiared_only] || false
+    end
+
+    def to_csv(columns = nil)
+      _columns = columns || COLUMS
+      r = "#{_columns.join(';')}\n"
+      rows.each do |row|
+        r << row.to_csv(_columns)
+        r << "\n"
+      end
+      r
+    end
+
+    def clients
+      filter(:clients)
+    end
+
+    def modes
+      filter(:modes)
+    end
+
+    def new_row(p)
+      ParamReport.new do |pr|
+        pr.parameter = p
+        pr.full_name = p.full_name
+        pr.klass = p.class
+        pr.parent = p.parent
+        pr.group = p.group
+        pr.modes = p.modes
+        pr.clients = p.binary_matcher.clients
+        pr.requirement = p.binary_matcher.requirement
+        pr.have_value_validator = !p.options[:value_validator].nil?
+        pr.have_switch_value = !p.options[:switch_value].nil?
+        pr.accepted_values = accepted_values_get(p)
+        pr.desc = p.desc
+      end
+    end
+
+    def accepted_values_get(p)
+      xxx_list_keys(:switch ,p) + xxx_list_keys(:chose, p)
+    end
+
+    def xxx_list_keys(list, p)
+      list = p.send("#{list}_list".to_sym)
+      return list.keys if list
+      []
+    end
+
+    def write(file, format = :csv)
+      fail "Fiele #{file} exists. Use #write!" if File.exists?(file)
+      write!(file, format)
+    end
+
+    def write!(file, format = :csv)
+      f = File.new(file, 'w')
+      f.write send("to_#{format}".to_sym)
+      f.close
+    end
+
+    def rows
+      @rows ||= []
+    end
+
+    def not_filtred?(p)
+      return skip?(p) if skipped_only?
+      clients?(p) && modes?(p)
+    end
+
+    def clients?(p)
+      (p.binary_matcher.clients & filter(:clients)).size > 0
+    end
+
+    def modes?(p)
+      (p.modes & filter(:modes)).size > 0
+    end
+
+    def skip?(p)
+      p.is_a? AssLauncher::Enterprise::Cli::Parameters::Skip
+    end
+
+    def execute
+      AssLauncher::Enterprise::Cli::CliSpec
+        .cli_def.parameters.parameters.each do |p|
+        rows << new_row(p) if match_version?(p) && not_filtred?(p)
+      end
+      self
+    end
+
+    def match_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
+  end
+end

data/bin/lib/dev_helper/cli_def_snippets.rb

@@ -0,0 +1,426 @@
+class String
+  def snakize
+    gsub(/(.)([A-Z])/,'\1_\2').downcase
+  end
+end
+module DevHelper
+  module CliDefSnippets
+    require 'clamp'
+    module Cmd
+      module Colorize
+        require 'coderay'
+        CodeRay::Encoders::Terminal::TOKEN_COLORS[:comment][:self] = "\e[1;34m"
+
+        def colorize_puts(str)
+          $stdout.puts colorize(str)
+        end
+
+        def colorize(str)
+          return CodeRay.scan(str, :ruby).terminal if colorize?
+          str
+        end
+        private :colorize
+
+        def self.included(klass)
+          klass.instance_eval do
+            option "--colorize", :flag, "colorize out"
+          end
+        end
+      end
+
+      module SpecDsl
+        class AbstractSpecDsl < Clamp::Command
+          include Colorize
+          option ['-n', '--name'], 'NAME', 'parameter name', required: true
+
+          def self.banner
+            "snippet for <#{dsl_method}> DSL method"
+          end
+
+          def self.dsl_method
+            name.split('::').last.snakize
+          end
+
+          def dsl_method
+            self.class.dsl_method
+          end
+        end
+
+        class New < Clamp::Command
+          BANNER = 'snippet for specification parameter'
+          class Abstract < AbstractSpecDsl
+            option ['-s', '--subparameters'], 'SPECS ...',
+              'generate reduced snippet'\
+              ' for subparameters like "type \'NAME\' ..."' do |s|
+              s.split
+            end
+
+            option ['-g', '--group'], 'GROUP', 'group of parameter.'\
+                ' Uses with --modes' do |s|
+              s.downcase.to_sym
+            end
+
+            option ['-m', '--modes'], 'MODES ...',
+              'run modes for which parameter defined'\
+                ' Uses with --group' do |s|
+              s.split.map(&:downcase).map(&:to_sym)
+            end
+
+            option ['-d', '--desc'], 'DESC', 'parameter description.'
+
+            option ['-c','--clients'], 'CLIENTS ...',
+              'clients for which parameter defined' do |s|
+              s.split.map(&:to_sym).map(&:downcase)
+            end
+
+            option '--validator', :flag,
+              'snippet will be generate with :value_validator stub'
+
+            option '--required', :flag,
+              'snippet will be generate with option :required => true'
+
+            def args
+              r = {}
+              r[:name] = name
+              r[:subparameters] = subparameters if subparameters
+              r[:group] = group if group
+              r[:modes] = modes if modes
+              r[:desc] = desc if desc
+              r[:clients] = clients if clients
+              r[:value_validator] = validator? if validator?
+              r[:required] = required? if required?
+              r
+            end
+
+            def execute
+              signal_usage_error 'Use --group & --modes together' if\
+                (group.nil? ^ modes.nil?)
+              begin
+                #$stdout.puts\
+                colorize_puts\
+                  CliDefSnippets::SpecDsl::Param.new(dsl_method, **args)\
+                  .to_snippet
+              rescue ArgumentError => e
+                signal_usage_error e.message
+              end
+            end
+          end
+
+          class String < New::Abstract; end
+          class Flag < String; end
+          class Path < New::Abstract; end
+          class PathExist < New::Abstract; end
+          class PathNotExist < New::Abstract; end
+          class Url < New::Abstract; end
+          class Num < New::Abstract; end
+          class Switch < New::Abstract
+            option ['-l', '--switch-list'], 'VALUES ...', 'list of accepted values',
+              required: true do |s|
+              s.split.map(&:to_sym)
+            end
+
+            def args
+              r = super
+              r[:switch_list] = switch_list
+              r
+            end
+          end
+
+          class Chose < New::Abstract
+            option ['-l', '--chose-list'], 'VALUES ...', 'list of accepted values',
+              required: true do |s|
+              s.split.map(&:to_sym)
+            end
+
+            def args
+              r = super
+              r[:chose_list] = chose_list
+              r
+            end
+          end
+
+          DSL_METHODS = {
+            'string' => [String.banner, String],
+            'flag' => [Flag.banner, Flag],
+            'path' => [Path.banner, Path],
+            'path_exist' => [Path.banner, PathExist],
+            'path_not_exist' => [Path.banner, PathNotExist],
+            'url' => [Url.banner, Url],
+            'num' => [Num.banner, Num],
+            'switch' => [Switch.banner, Switch],
+            'chose' => [Chose.banner, Chose]
+          }
+
+          DSL_METHODS.each do |k,v|
+            subcommand k, *v
+          end
+
+#          subcommand 'string', String.banner, String
+#          subcommand 'path', Path.banner, Path
+#          subcommand 'path_exist', Path.banner, PathExist
+#          subcommand 'path_not_exist', Path.banner, PathNotExist
+#          subcommand 'url', Url.banner, Url
+#          subcommand 'num', Num.banner, Num
+#          subcommand 'switch', Switch.banner, Switch
+#          subcommand 'chose', Chose.banner, Chose
+        end
+
+        class Restrict < AbstractSpecDsl
+          BANNER = 'snippet for restrict parameter'
+
+          def execute
+            begin
+              #$stdout.puts\
+              colorize_puts\
+                CliDefSnippets::SpecDsl::Restrict.new(name)\
+                  .to_s
+            rescue ArgumentError => e
+              signal_usage_error e.message
+            end
+          end
+        end
+
+        class Change < AbstractSpecDsl
+          BANNER = 'snippet for change parameter specification'
+
+          option ['-s', '--subparameters'], 'SPECS ...',
+            'generate reduced snippet'\
+            ' for subparameters like "type \'NAME\' ..."' do |s|
+            s.split
+          end
+
+          def args
+            r = {}
+            r[:name] = name
+            r[:subparameters] = subparameters if subparameters
+#            r[:group] = group if group
+#            r[:modes] = modes if modes
+#            r[:desc] = desc if desc
+#            r[:clients] = clients if clients
+#            r[:value_validator] = validator? if validator?
+#            r[:required] = required? if required?
+            r
+          end
+
+          def execute
+            begin
+#              colorize_puts\
+#                CliDefSnippets::SpecDsl::Restrict.new(name)\
+#                .to_s
+#              $stdout.puts fail('FIXME')
+              colorize_puts\
+                CliDefSnippets::SpecDsl::Change.new(name, **args).to_snippet
+            rescue ArgumentError => e
+              signal_usage_error e.message
+            end
+          end
+        end
+      end
+
+      class Main < Clamp::Command
+        def self._banner
+         'generator snippets on DSL (see AssLauncher::Enterprise::Cli::SpdecDsl)'
+        end
+
+        subcommand 'new', SpecDsl::New::BANNER, SpecDsl::New
+        subcommand 'restrict', SpecDsl::Restrict::BANNER, SpecDsl::Restrict
+        subcommand 'change', SpecDsl::Change::BANNER, SpecDsl::Change
+      end
+    end
+
+    module SpecDsl
+      class Group
+        include DevHelper::CliDefValidator
+        attr_reader :name
+        def initialize(name)
+          @name = name
+          validate_group if self.class == Group
+        end
+
+        def group_name
+          name
+        end
+
+        def self.dsl_method
+          name.split('::').last.snakize
+        end
+
+        def dsl_method
+          self.class.dsl_method
+        end
+
+        def indents
+          2
+        end
+
+        def indent(inclosure)
+          inclosure.gsub(/^/,' ' * indents)
+        end
+
+        def dsl_method_args
+          ":#{name.to_sym.downcase}"
+        end
+
+        def to_s(inclosure = '')
+          r = ''
+          r << "#{dsl_method} #{dsl_method_args} do\n"
+          r << indent(inclosure) + "\n"
+          r << 'end'
+        end
+      end
+
+      class Restrict < Group
+        def to_s
+          "#{dsl_method} '#{name}'"
+        end
+      end
+
+      class Mode < Group
+        attr_reader :modes
+        def initialize(modes)
+          @modes = modes
+          validate_modes
+        end
+
+        def dsl_method_args
+          modes.map(&:to_sym).map(&:downcase).to_s.gsub(/(\[|\])/,'')
+        end
+      end
+
+      class Param < Group
+        DEFAULT_ARGS = {
+          subparameters: [],
+          group: nil,
+          modes: nil,
+          desc: nil,
+          clients: nil,
+          value_validator: nil,
+          required: nil,
+          chose_list: nil,
+          switch_list: nil
+        }
+        def initialize(dsl_method, **args)
+          @name = args[:name]
+          @dsl_method = dsl_method
+          @args = DEFAULT_ARGS.merge args
+          validate_clients if clients
+        end
+
+        def DSL_METHODS
+          Cmd::SpecDsl::New::DSL_METHODS
+        end
+
+        def valid_dsl_method(method)
+          fail ArgumentError, "Invalid DSL method `#{method}'."\
+            " Expects: #{DSL_METHODS().keys.to_s}" unless\
+            DSL_METHODS().keys.include? method
+          method
+        end
+
+        attr_reader :args, :dsl_method
+
+        def to_dsl_method(name)
+          signal_usage_error "--subparameters SPECS format:"\
+            " `ptype:pname' or `pname'" if name.split(':').size > 2
+          return '#FIXME: ptype' if name.split(':').size == 1
+          valid_dsl_method name.split(':')[0]
+        end
+
+        def subparameters_to_s
+          subparameters.map do |name|
+            Param.new(to_dsl_method(name),
+                      name: name.split(':').last,
+                      desc: 'FIXME: description',
+                      clients: clients,
+                      required: '#FIXME: bool',
+                      ).to_snippet
+          end.join("\n")
+        end
+
+        def method_missing(m, *_)
+          fail NoMethodError unless args.key? m
+          args[m]
+        end
+
+        def switch_list_stub(i)
+          list_stub(switch_list, i)
+        end
+
+        def chose_list_stub(i)
+          list_stub(chose_list, i)
+        end
+
+        def list_stub(list, i)
+          list.map(&:to_sym).to_s.gsub(/(\[|\])/,'').split(',').map do |item|
+            "#{item} => 'FIXME: description'"
+          end.join(",#{nl(i)}")
+        end
+
+        def nl(i)
+          "\n#{' '*i}"
+        end
+
+        def dsl_method_args(i)
+          r = "'#{name}'"
+          r << ", '#{desc}'" if desc
+          r << ", #{clients.map(&:to_s).map(&:downcase)
+            .to_s.gsub(/(\[|\]|")/,'')}" if clients
+          r << ", required: #{required}" if required
+          if switch_list
+            h = ",#{nl(i)}switch_list: switch_list("
+            r << "#{h}#{switch_list_stub(h.size - 3)})"\
+          end
+          if chose_list
+            h = ",#{nl(i)}chose_list: chose_list("
+            r << "#{h}#{chose_list_stub(h.size - 3)})"\
+          end
+          r << ",#{nl(i)}value_validator: proc {|value| fail 'FIXME'}" if\
+            value_validator
+          r
+        end
+
+        def to_s(inclosure = '')
+          r = "#{dsl_method} #{dsl_method_args(dsl_method.size + 1)}"
+          unless inclosure.empty?
+            r << " do\n"
+            r << indent(inclosure) + "\n"
+            r << 'end'
+          end
+          r
+        end
+
+        def wrrapp(s)
+          g = Group.new(group)
+          m = Mode.new(modes)
+          g.to_s(m.to_s(s))
+        end
+
+        def to_snippet
+          return wrrapp(to_s(subparameters_to_s)) if group
+          to_s(subparameters_to_s)
+        end
+      end
+
+      class Change < Param
+        def subparameters_to_s
+          subparameters.map do |name|
+            r = ''
+            r << Restrict.new(name.split(':').last).to_s
+            r << "\n"
+            r << Param.new(to_dsl_method(name),
+                      name: name.split(':').last,
+                      desc: 'FIXME: description',
+                      clients: clients,
+                      required: '#FIXME: bool',
+                      ).to_snippet
+            r
+          end.join("\n")
+        end
+
+        def dsl_method
+          :change
+        end
+      end
+    end
+  end
+end