Module: IDL::Ruby

Defined in:

lib/ridlbe/ruby/config.rb

Overview

module RIDL

Defined Under Namespace

Modules: LeafMixin, ScannerMixin

Constant Summary

COPYRIGHT =

"Copyright (c) 2007-#{Time.now.year} Remedy IT Expertise BV, The Netherlands".freeze

TITLE =

'RIDL Ruby backend'.freeze

VERSION =

{
  :major => 2,
  :minor => 0,
  :release => 1
}

Class Method Summary

• .process_input(parser, options, outstream = nil) ⇒ Object

  Backend.configure.

Instance Method Summary

• #ruby ⇒ Object

  Configure Ruby backend.

Class Method Details

.process_input(parser, options, outstream = nil) ⇒ Object

Backend.configure

# File 'lib/ridlbe/ruby/config.rb', line 208

def self.process_input(parser, options, outstream = nil)
  # has a user defined output filename been set
  fixed_output = !options[:output].nil?

  # determine output file path for client stub code
  unless fixed_output || options[:idlfile].nil?
    options[:output] = options[:outputdir] + '/' + File.basename(options[:idlfile], '.idl') + options[:stub_pfx] + '.rb'
  end
  # generate client stubs if requested
  if options[:client_stubs]
    # open output file
    co = outstream || (if options[:output].nil?
       GenFile.new(nil, :output_file => $stdout)
      else
        GenFile.new(options[:output])
      end)
    begin
      # process StubWriter
      parser.visit_nodes(::IDL::RubyStubWriter.new(co, options))
    rescue => ex
      IDL.log(0, ex)
      IDL.log(0, ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
      exit 1
    end
  end

  # determin output file path for servant code and open file
  unless options[:stubs_only]
    so = outstream || (unless fixed_output || options[:idlfile].nil?
        options[:srv_output] = if fixed_output
            options[:output]
          else
            options[:outputdir] + '/' + File.basename(options[:idlfile], '.idl') + options[:srv_pfx] + '.rb'
          end
        if fixed_output && options[:client_stubs]
          co
        else
          GenFile.new(options[:srv_output])
        end
      else
        GenFile.new(nil, :output_file => $stdout)
      end)
    begin
      # process ServantWriter
      parser.visit_nodes(::IDL::RubyServantWriter.new(so, options))
    rescue => ex
      IDL.log(0, ex)
      IDL.log(0, ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
      exit 1
    end
  end
end

Instance Method Details

#ruby ⇒ Object

Configure Ruby backend

# File 'lib/ridlbe/ruby/config.rb', line 100

Backend.configure('ruby', File.dirname(__FILE__), TITLE, COPYRIGHT, VERSION) do |becfg|

  # setup backend option handling
  #
  becfg.on_setup do |optlist, ridl_params|
    # defaults
    ridl_params[:stub_pfx] = 'C'
    ridl_params[:srv_pfx] = 'S'
    ridl_params[:stubs_only] = false
    ridl_params[:client_stubs] = true
    ridl_params[:expand_includes] = false
    ridl_params[:libinit] = true
    ridl_params[:class_interfaces] = []

    # ruby specific option switches

    unless ridl_params[:preprocess] # same switch defined for IDL preprocessing mode
      optlist.for_switch '--output=FILE', :type => String,
          :description => ['Specifies filename to generate output in.',
                           'Default: File.basename(idlfile, \'.idl\')+<postfix>+<ext>'] do |swcfg|
        swcfg.on_exec do |arg, params|
          params[:output] = arg
        end

      end
    end

    optlist.for_switch '-o PATH', :type => String,
        :description => ['Specifies output directory.',
                         'Default: ./'] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:outputdir] = arg
      end
    end
    optlist.for_switch '--stubs-only',
        :description => ['Only generate client stubs, no servant code.',
                         'Default: off'] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:client_stubs] = true
        params[:stubs_only] = true
      end
    end
    optlist.for_switch '--no-stubs',
        :description => ['Do not generate client stubs, only servant code.',
                         'Default: off'] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:client_stubs] = false
        params[:stubs_only] = false
      end
    end
    optlist.for_switch '--stub-pfx=POSTFIX', :type => String,
        :description => ['Specifies postfix for generated client stub source filename.',
                         'Filenames are formed like: <idl basename><postfix>.<language extension>',
                         "Default: #{ridl_params[:stub_pfx]}"] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:stub_pfx] = arg
      end
    end
    optlist.for_switch '--skel-pfx=POSTFIX', :type => String,
        :description => ['Specifies postfix for generated servant skeleton source filename.',
                         'Filenames are formed like: <idl basename><postfix>.<language extension>',
                         "Default: #{ridl_params[:srv_pfx]}"] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:srv_pfx] = arg
      end
    end

    optlist.for_switch '--skel-directory=PATH', :type => String,
        :description => ['Specifies output directory for servant files.',
                         'Default: outputdir or ./'] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:skel_outputdir] = arg
      end
    end
    optlist.for_switch '--expand-includes',
        :description => ['Generate code for included IDL inline.',
                         'Default: off'] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:expand_includes] = true
      end
    end
    optlist.for_switch '--no-libinit',
        :description => ['Do not generate library initialization code as preamble.',
                         'Default: on'] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:libinit] = false
      end
    end
    optlist.for_switch '--interface-as-class=INTF', :type => String,
        :description => ['Generate a Ruby class for interface INTF instead of a module in client stubs.',
                         'Default: module'] do |swcfg|
      swcfg.on_exec do |arg, params|
        params[:class_interfaces] << arg
      end
    end
  end

  # process input / generate code
  # arguments:
  #   in parser - parser object with full AST from parsed source
  #   in options - initialized option hash
  #
  becfg.on_process_input do |parser, options|
    IDL::Ruby.process_input(parser, options)
  end # becfg.on_process_input

end