ridl 2.8.2 → 2.9.0

data/lib/ridl/options.rb

@@ -14,13 +14,11 @@ require 'ostruct'
 require 'json'
 
 module IDL
-
   RIDLRC = '.ridlrc'
   RIDLRC_GLOBAL = File.expand_path(File.join(ENV['HOME'] || ENV['HOMEPATH'] || '~', RIDLRC))
 
   class Options < OpenStruct
-
-    def initialize(hash=nil, marked=nil)
+    def initialize(hash = nil, marked = nil)
       super(hash)
       @marked = marked
     end
@@ -35,7 +33,7 @@ module IDL
     end
 
     def copy!(from, *keys)
-      keys.flatten.each {|k| self[k] = from[k] }
+      keys.flatten.each { |k| self[k] = from[k] }
       self
     end
 
@@ -67,7 +65,6 @@ module IDL
       self.class.new(_dup_elem(@marked || @table), @marked)
     end
 
-
     def load(rcpath)
       IDL.log(3, "Loading #{RIDLRC} from #{rcpath}")
       _cfg = JSON.parse(IO.read(rcpath))
@@ -94,7 +91,7 @@ module IDL
     protected
 
     def _merge(to, from, *keys)
-      keys = keys.flatten.collect {|k| k.to_sym}
+      keys = keys.flatten.collect { |k| k.to_sym }
       keys = from.keys if keys.empty?
       keys.each do |k|
         if from.has_key?(k)
@@ -122,9 +119,10 @@ module IDL
     def _dup_elem(v)
       case v
       when Array
-        v.collect {|e| _dup_elem(e) }
+        v.collect { |e| _dup_elem(e) }
       when Hash
-        v.inject({}) {|h, (k, e)| h[k] = _dup_elem(e); h }
+        v.inject({}) { |h, (k, e)| h[k] = _dup_elem(e)
+ h }
       when OpenStruct
         v.class.new(_dup_elem(v.__send__(:table)))
       else
@@ -136,12 +134,12 @@ module IDL
 
     def self.load_config(opt)
       # first collect config from known (standard and configured) locations
-      _rc_paths = [ RIDLRC_GLOBAL ]
+      _rc_paths = [RIDLRC_GLOBAL]
       _loaded_rc_paths = []
       (ENV['RIDLRC'] || '').split(/:|;/).each do |p|
         _rc_paths << p unless _rc_paths.include?(p)
       end
-      _rc_paths.collect {|path| File.expand_path(path) }.each do |rcp|
+      _rc_paths.collect { |path| File.expand_path(path) }.each do |rcp|
         IDL.log(3, "Testing rc path #{rcp}")
         if File.readable?(rcp) && !_loaded_rc_paths.include?(rcp)
           opt.load(rcp)
@@ -163,6 +161,7 @@ module IDL
           IDL.log(3, "Ignoring #{File.readable?(_rcp) ? 'already loaded' : 'inaccessible'} rc path #{_rcp}")
         end
         break if /\A(.:(\\|\/)|\.|\/)\Z/ =~ _cwd
+
         _cwd = File.dirname(_cwd)
       end while true
       # now load them in reverse order
@@ -172,5 +171,4 @@ module IDL
       end
     end
   end
-
 end

data/lib/ridl/optparse_ext.rb

@@ -47,13 +47,9 @@ end
 
 module IDL
   class OptionList
-
     class Option
-
       class Group
-
         class ParamSet
-
           class Configurator
             def initialize(set)
               @set = set
@@ -70,11 +66,12 @@ module IDL
             end
 
             def without(*params)
-              params.each {|p| @set.params.delete(p.to_sym) }
+              params.each { |p| @set.params.delete(p.to_sym) }
             end
           end
 
           attr_reader :params
+
           def initialize(options)
             @description = Array === options[:description] ? options[:description] : (options[:description] || '').split('\n')
             @all_params = options[:all_params] == true
@@ -108,7 +105,7 @@ module IDL
           end
 
           def description
-            @params.values.inject(@description) {|list, vopt| list.concat(vopt[:description] || []) }
+            @params.values.inject(@description) { |list, vopt| list.concat(vopt[:description] || []) }
           end
 
           def define_params(spec = {})
@@ -116,7 +113,7 @@ module IDL
             when String, Hash
               define_param(spec)
             when Array
-              spec.each {|p| define_param(p) }
+              spec.each { |p| define_param(p) }
             end
           end
 
@@ -124,6 +121,7 @@ module IDL
 
           def to_key(param)
             return param if Symbol === param
+
             # convert empty strings to single space strings before symbolizing
             String === param ? (param.empty? ? ' ' : param).to_sym : nil
           end
@@ -132,18 +130,18 @@ module IDL
             case spec
             when String
               key = to_key(spec)
-              @params[key] = { :option_name => key }
+              @params[key] = { option_name: key }
             when Hash
               spec.each do |k, v|
                 @params[to_key(k)] = (if Hash === v
                   {
-                    :option_name => to_key(v[:option_name] || k),
-                    :option_type => v[:type],
-                    :option_value => v.has_key?(:value) ? v[:value] : true,
-                    :description => Array === v[:description] ? v[:description] : (v[:description] || '').split('\n')
+                    option_name: to_key(v[:option_name] || k),
+                    option_type: v[:type],
+                    option_value: v.has_key?(:value) ? v[:value] : true,
+                    description: Array === v[:description] ? v[:description] : (v[:description] || '').split('\n')
                   }
                 else
-                  { :option_name => to_key(v) }
+                  { option_name: to_key(v) }
                 end)
               end
             end
@@ -164,6 +162,7 @@ module IDL
           def define_param_set(id, options = {}, &block)
             id = id.to_sym
             raise "option parameter set [#{id}] already exists" if @group.sets.has_key?(id)
+
             @group.sets[id] = ParamSet.new(options)
             block.call(ParamSet::Configurator.new(@group.sets[id])) if block_given?
           end
@@ -179,7 +178,7 @@ module IDL
           alias :modify_params :modify_param_set
           alias :with_params :modify_param_set
 
-          def define_param(id, options={}, &block)
+          def define_param(id, options = {}, &block)
             define_param_set("#{id}_set", options) do |pscfg|
               pscfg.with(id)
               pscfg.on_exec(&block)
@@ -193,21 +192,21 @@ module IDL
           end
           alias :without_set :without_param
           alias :without_params :without_param
-
         end # Configurator
 
         attr_reader :sets
+
         def initialize(id, options)
           @test = options[:test] || true
           @description = Array === options[:description] ? options[:description] : (options[:description] || '').split('\n')
           @sets = {}
           if options[:params] && Hash === options[:params]
-            @sets[id] = ParamSet.new(:params => options[:params])
+            @sets[id] = ParamSet.new(params: options[:params])
           end
         end
 
         def description
-          @sets.values.inject(@description.dup) {|desc, a| desc.concat(a.description) }
+          @sets.values.inject(@description.dup) { |desc, a| desc.concat(a.description) }
         end
 
         def run(arg, options)
@@ -215,6 +214,7 @@ module IDL
           if self.respond_to?(:_prepare, true)
             result = _prepare(arg, options)
             return false unless result && !result.empty?
+
             arg = result.shift
             ext_args = result
           else
@@ -232,7 +232,7 @@ module IDL
         private
 
         def handle_sets(param, options, *ext_args)
-          @sets.values.inject(false) {|f, s| s.run(param, options, *ext_args) || f }
+          @sets.values.inject(false) { |f, s| s.run(param, options, *ext_args) || f }
         end
       end # Group
 
@@ -244,6 +244,7 @@ module IDL
         def define_group(id, options = {}, &block)
           id = id.to_sym
           raise "option group [#{id}] already exists" if @option.groups.has_key?(id)
+
           @option.groups[id] = Group.new(id, options)
           block.call(Group::Configurator.new(@option.groups[id])) if block_given?
         end
@@ -254,7 +255,7 @@ module IDL
           parms = options[:params] ? options.delete(:params) : options.delete(:param)
           @option.groups[id] ||= Group.new(id, options)
           grpcfg = Group::Configurator.new(@option.groups[id])
-          grpcfg.modify_param_set(id, :params => parms) if parms
+          grpcfg.modify_param_set(id, params: parms) if parms
           block.call(grpcfg) if block_given?
         end
         alias :with_group :modify_group
@@ -264,23 +265,23 @@ module IDL
         end
 
         def define_param_set(id, options = {}, &block)
-          modify_group :default, {:test => true} do |grpcfg|
+          modify_group :default, {test: true} do |grpcfg|
             grpcfg.define_param_set(id, options, &block)
           end
         end
         alias :for_set :define_param_set
         alias :for_params :define_param_set
 
-        def on_exec(options={}, &block)
-          modify_group :default, {:test => true} do |grpcfg|
-            grpcfg.modify_param_set(:default, options.merge({:all_params => true})) do |pscfg|
+        def on_exec(options = {}, &block)
+          modify_group :default, {test: true} do |grpcfg|
+            grpcfg.modify_param_set(:default, options.merge({all_params: true})) do |pscfg|
               pscfg.on_exec(&block)
             end
           end
         end
 
-        def define_param(id, options={}, &block)
-          modify_group :default, {:test => true} do |grpcfg|
+        def define_param(id, options = {}, &block)
+          modify_group :default, {test: true} do |grpcfg|
             grpcfg.define_param_set("#{id}_set", options) do |pscfg|
               pscfg.with(id)
               pscfg.on_exec(&block)
@@ -300,10 +301,8 @@ module IDL
         alias :without_params :without_param
       end
 
-      attr_reader :switch
-      attr_reader :type
-      attr_reader :separator
-      attr_reader :groups
+      attr_reader :switch, :type, :separator, :groups
+
       def initialize(switch, options)
         @switch = switch
         @type = options[:type] || TrueClass
@@ -313,23 +312,24 @@ module IDL
       end
 
       def description(indent = "")
-        @groups.values.inject(@description.dup) {|desc, h| desc.concat(h.description.collect {|desc| "\r#{indent}  #{desc}"}) }
+        @groups.values.inject(@description.dup) { |desc, h| desc.concat(h.description.collect { |desc| "\r#{indent}  #{desc}" }) }
       end
 
       def run(arg, options)
-        unless @groups.values.inject(false) {|f, h| h.run(arg, options) || f }
+        unless @groups.values.inject(false) { |f, h| h.run(arg, options) || f }
           raise ArgumentError, "unknown option [#{arg}] for switch '#{@switch}'"
         end
       end
     end # Option
 
-    def initialize()
+    def initialize
       @options = {}
     end
 
     def define_switch(switch, options = {}, &block)
       switch = switch.to_s
       raise "switch types mismatch" if @options.has_key?(switch) && options[:type] && options[:type] != @options[switch].type
+
       @options[switch] ||= Option.new(switch, options)
       block.call(Option::Configurator.new(@options[switch])) if block_given?
     end
@@ -351,7 +351,5 @@ module IDL
         optp.separator '' if op.separator
       end
     end
-
   end # OptionList
-
 end # IDL

data/lib/ridl/parser.rb

@@ -648,7 +648,6 @@ end
 require 'ridl/delegate'
 
 module IDL
-
 class Parser < Racc::Parser
 
 module_eval(<<'...end parser.ry/module_eval...', 'parser.ry', 830)
@@ -4247,6 +4246,4 @@ def _reduce_none(val, _values)
 end
 
 end   # class Parser
-
-
 end #of module IDL

data/lib/ridl/runner.rb

@@ -18,23 +18,21 @@ require 'ridl/options'
 # -----------------------------------------------------------------------
 
 module IDL
-
   OPTIONS = Options.new({
-      :outputdir       => nil,
-      :includepaths    => [],
-      :xincludepaths   => [],
-      :verbose         => (ENV['RIDL_VERBOSE'] || 0).to_i,
-      :debug           => false,
-      :namespace       => nil,
-      :search_incpath  => false,
-      :backend         => nil,
-      :macros          => {
+      outputdir: nil,
+      includepaths: [],
+      xincludepaths: [],
+      verbose: (ENV['RIDL_VERBOSE'] || 0).to_i,
+      debug: false,
+      namespace: nil,
+      search_incpath: false,
+      backend: nil,
+      macros: {
       }
   })
   CORE_OPTIONS = OPTIONS.keys
 
   class Engine
-
     class ProductionStack
       def initialize
         @stack = []
@@ -56,6 +54,7 @@ module IDL
 
       def pop
         return nil if empty?
+
         id, prod = @stack.shift
         @index.delete(id)
         prod
@@ -63,12 +62,14 @@ module IDL
 
       def peek
         return nil if empty?
+
         id, _ = @stack.first
         id
       end
 
       def remove(id)
         return nil unless has?(id)
+
         i = @index.delete(id.to_sym)
         _, producer = @productionstack.delete(i)
         producer
@@ -129,6 +130,7 @@ module IDL
 
     def push_production(id, producer)
       raise "Producer #{id} already queued" if @productionstack.has?(id)
+
       @productionstack.push(id, producer)
     end
 
@@ -183,9 +185,9 @@ module IDL
         # parse arguments
         begin
           @optparser.parse!(argv)
-        rescue ArgumentError => ex
-          IDL.error(ex.inspect)
-          IDL.error(ex.backtrace.join("\n")) if IDL.verbose_level > 0
+        rescue ArgumentError => e
+          IDL.error(e.inspect)
+          IDL.error(e.backtrace.join("\n")) if IDL.verbose_level.positive?
           return false
         end
 
@@ -231,7 +233,7 @@ module IDL
             # process parse result -> code generation
             IDL.log(2, 'RIDL - processing input')
 
-            GenFile.transaction  do
+            GenFile.transaction do
               begin
 
                 backend.process_input(_parser, _opts)
@@ -250,9 +252,9 @@ module IDL
               rescue Backend::ProcessStop
                 IDL.log(2, "RIDL - processing #{IO === _idlfile ? 'from STDIN' : (StringIO === _idlfile ? 'from string' : _idlfile)} stopped with \"#{$!.message}\"")
 
-              rescue => ex
-                IDL.error(ex)
-                IDL.error(ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
+              rescue => e
+                IDL.error(e)
+                IDL.error(e.backtrace.join("\n")) unless e.is_a? IDL::ParseError
                 return false
               end
             end
@@ -272,9 +274,9 @@ module IDL
 
       begin
         _parser.parse(io)
-      rescue => ex
-        IDL.error(ex.inspect)
-        IDL.error(ex.backtrace.join("\n")) unless ex.is_a? IDL::ParseError
+      rescue => e
+        IDL.error(e.inspect)
+        IDL.error(e.backtrace.join("\n")) unless e.is_a? IDL::ParseError
         return nil
       ensure
         io.close unless String === io || io == $stdin
@@ -328,7 +330,7 @@ module IDL
 
     def init_optparser
       script_name = File.basename($0, '.*')
-      if not script_name =~ /ridlc/
+      unless script_name =~ /ridlc/
         script_name = 'ruby ' + $0
       end
 
@@ -398,11 +400,12 @@ module IDL
       opts.separator ""
 
       opts.on('-h', '--help',
-              'Show this help message.') { puts opts; puts; exit }
+              'Show this help message.') { puts opts
+ puts
+ exit }
 
       opts
     end
-
   end
 
   def IDL.engine?
@@ -419,11 +422,13 @@ module IDL
 
   def IDL.pop_input
     return nil unless engine?
+
     Thread.current[:ridl_engine].pop_input
   end
 
   def IDL.peek_input
     return nil unless engine?
+
     Thread.current[:ridl_engine].peek_input
   end
 
@@ -437,11 +442,13 @@ module IDL
 
   def IDL.pop_production
     return nil unless engine?
+
     Thread.current[:ridl_engine].pop_production
   end
 
   def IDL.remove_production(id)
     return nil unless engine?
+
     Thread.current[:ridl_engine].remove_production(id)
   end
 
@@ -455,6 +462,7 @@ module IDL
 
   def IDL.production(id)
     return nil unless engine?
+
     Thread.current[:ridl_engine].production(id)
   end
 
@@ -503,7 +511,7 @@ module IDL
     # add optional search paths for RIDL backends
     options[:be_path] ||= []
     options[:be_path].unshift(*ENV['RIDL_BE_PATH'].split(/#{File::PATH_SEPARATOR}/)) if ENV['RIDL_BE_PATH']
-    options[:be_path].collect! {|p| p.gsub('\\', '/') } # cleanup to prevent mixed path separators
+    options[:be_path].collect! { |p| p.gsub('\\', '/') } # cleanup to prevent mixed path separators
     $:.concat(options[:be_path]) unless options[:be_path].empty?
 
     # check for special bootstrapping switches
@@ -527,5 +535,4 @@ module IDL
       exit(1) unless Thread.current[:ridl_engine].run(argv)
     end
   end # IDL.run
-
 end