ridl 2.8.2 → 2.9.0

data/lib/ridl/expression.rb

@@ -13,9 +13,11 @@ require 'ridl/node'
 
 module IDL
   class Expression
-    attr_reader :idltype
-    attr_reader :value
-    def typename; @idltype.typename; end
+    attr_reader :idltype, :value
+
+    def typename
+      @idltype.typename
+    end
 
     def is_template?
       false
@@ -34,6 +36,7 @@ module IDL
 
     class ScopedName < Expression
       attr_reader :node
+
       def initialize(node)
         if $DEBUG
           unless IDL::AST::Const === node || (IDL::AST::TemplateParam === node && node.idltype.is_a?(IDL::Type::Const))
@@ -44,9 +47,11 @@ module IDL
         @idltype = node.idltype
         @value = @idltype.narrow(node.value) unless node.is_template?
       end
+
       def is_template?
         @node.is_template?
       end
+
       def instantiate(instantiation_context)
         if self.is_template?
           cp = IDL::AST::TemplateParam.concrete_param(instantiation_context, @node)
@@ -55,9 +60,11 @@ module IDL
           self
         end
       end
+
       def is_node?(node_class)
         @node.is_a?(node_class)
       end
+
       def resolved_node
         @node
       end
@@ -65,9 +72,10 @@ module IDL
 
     class Enumerator < Expression
       attr_reader :node
+
       def initialize(node)
         if $DEBUG
-          if not IDL::AST::Enumerator === node
+          unless IDL::AST::Enumerator === node
             raise "#{node.scoped_name} must be enumerator: #{node.class.name}."
           end
         end
@@ -81,6 +89,7 @@ module IDL
       NUMBER_OF_OPERANDS = nil
 
       attr_reader :operands
+
       def initialize(*_operands)
         n = self.class::NUMBER_OF_OPERANDS
 
@@ -90,8 +99,8 @@ module IDL
         end
 
         unless _operands.any? { |o| o.is_template? }
-          @idltype = self.class.suite_type(*(_operands.collect{|o| o.idltype.resolved_type}))
-          @value = calculate(*(_operands.collect{|o| o.value}))
+          @idltype = self.class.suite_type(*(_operands.collect { |o| o.idltype.resolved_type }))
+          @value = calculate(*(_operands.collect { |o| o.value }))
         else
           @idltype = nil
           @value = nil
@@ -110,13 +119,13 @@ module IDL
 
       def Operation.suite_type(*types)
         types.each do |t|
-          if not self::Applicable.include? t.class
+          unless self::Applicable.include? t.class
             raise "#{self.name} cannot be applicable for #{t.typename}"
           end
         end
 
         ret = nil
-        types = types.collect {|t| t.class }
+        types = types.collect { |t| t.class }
         self::Applicable.each do |t|
           if types.include? t
             ret = t
@@ -125,13 +134,13 @@ module IDL
         end
         ret
       end
-      def set_type
-      end
+
+      def set_type; end
 
       class Unary < Operation
         NUMBER_OF_OPERANDS = 1
         Applicable = nil
-      end #of class Unary
+      end # of class Unary
 
       class Integer2 < Operation
         NUMBER_OF_OPERANDS = 2
@@ -143,12 +152,13 @@ module IDL
         ]
 
         def Integer2.suite_sign(_t, _v)
-          [ [IDL::Type::LongLong, IDL::Type::ULongLong],
+          [[IDL::Type::LongLong, IDL::Type::ULongLong],
             [IDL::Type::Long,     IDL::Type::ULong],
             [IDL::Type::Short,    IDL::Type::UShort]
-          ].each do |t|
+].each do |t|
             next unless t.include? _t
-            return (if _v < 0 then t[0] else t[1] end)
+
+            return (if _v.negative? then t[0] else t[1] end)
           end
         end
 
@@ -184,7 +194,8 @@ module IDL
           superclass.checktype(*types)
 
           # it's expected that Double, LongDouble is a Float.
-          s1, s2 = IDL::Type::Float, IDL::Type::Fixed
+          s1 = IDL::Type::Float
+          s2 = IDL::Type::Fixed
           if (t1 === s1 && t2 === s2) or (t1 === s2 && t2 === s1)
             raise "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
           end
@@ -197,19 +208,22 @@ module IDL
           op
         end
       end
+
       class UnaryMinus < Unary
         Applicable = Float2::Applicable
         def calculate(op)
           -op
         end
+
         def set_type
           @idltype = Integer2.suite_sign(@idltype, @value)
         end
       end
+
       class UnaryNot < Unary
         Applicable = Integer2::Applicable
         def calculate(op)
-          if @idltype.is_unsigned?()
+          if @idltype.is_unsigned?
             (2**@idltype.bits - 1) - op
           else
             ~op
@@ -218,29 +232,39 @@ module IDL
       end
 
       class Or < Boolean2
-        def calculate(lop, rop); lop | rop; end
+        def calculate(lop, rop)
+          lop | rop
+        end
       end
+
       class And < Boolean2
-        def calculate(lop, rop); lop & rop; end
+        def calculate(lop, rop)
+          lop & rop
+        end
       end
+
       class Xor < Boolean2
-        def calculate(lop, rop); lop ^ rop; end
+        def calculate(lop, rop)
+          lop ^ rop
+        end
       end
 
       class Shift < Integer2
       protected
         def check_rop(rop)
-          if not (0...64) === rop
+          unless (0...64) === rop
             raise "right operand for shift must be in the range 0 <= right operand < 64: #{rop}."
           end
         end
       end
+
       class LShift < Shift
         def calculate(lop, rop)
           check_rop(rop)
           lop << rop
         end
       end
+
       class RShift < Shift
         def calculate(lop, rop)
           check_rop(rop)
@@ -249,20 +273,34 @@ module IDL
       end
 
       class Add < Float2
-        def calculate(lop, rop); lop + rop; end
+        def calculate(lop, rop)
+          lop + rop
+        end
       end
+
       class Minus < Float2
-        def calculate(lop, rop); lop - rop; end
+        def calculate(lop, rop)
+          lop - rop
+        end
       end
+
       class Mult < Float2
-        def calculate(lop, rop); lop * rop; end
+        def calculate(lop, rop)
+          lop * rop
+        end
       end
+
       class Div < Float2
-        def calculate(lop, rop); lop / rop; end
+        def calculate(lop, rop)
+          lop / rop
+        end
       end
+
       class Mod < Integer2
-        def calculate(lop, rop); lop % rop; end
+        def calculate(lop, rop)
+          lop % rop
+        end
       end
-    end #of class Operation
-  end #of class Expression
+    end # of class Operation
+  end # of class Expression
 end

data/lib/ridl/genfile.rb

@@ -13,9 +13,7 @@ require 'tempfile'
 require 'fileutils'
 
 module IDL
-
   class GenFile
-
     self.singleton_class.class_eval do
       private
 
@@ -37,11 +35,13 @@ module IDL
       end
 
       def _commit
-        _transaction.reject! { |fgen| fgen.save; true }
+        _transaction.reject! { |fgen| fgen.save
+ true }
       end
 
       def _rollback
-        _transaction.reject! { |fgen| fgen.remove; true } if _transaction
+        _transaction.reject! { |fgen| fgen.remove
+ true } if _transaction
       end
 
       def _push(fgen)
@@ -67,7 +67,8 @@ module IDL
     class Content
       def initialize(sections = {})
         # copy content map transforming all keys to symbols
-        @sections = sections.inject({}) {|m, (k, v)| m[k.to_sym] = v; m }
+        @sections = sections.inject({}) { |m, (k, v)| m[k.to_sym] = v
+ m }
       end
 
       def sections
@@ -101,13 +102,13 @@ module IDL
         @path = @fullpath = @name = @ext = ''
       end
       @options = {
-        :regenerate => false,
-        :regen_marker_prefix => '//',
-        :regen_marker_postfix => nil,
-        :regen_marker => REGEN_MARKER_DEFAULT,
-        :regen_keep_header => true,
-        :output_file => nil,
-        :create_missing_dir => false
+        regenerate: false,
+        regen_marker_prefix: '//',
+        regen_marker_postfix: nil,
+        regen_marker: REGEN_MARKER_DEFAULT,
+        regen_keep_header: true,
+        output_file: nil,
+        create_missing_dir: false
       }.merge(opts)
       if @options[:regenerate] && File.exist?(@fullpath)
         parse_regeneration_content
@@ -144,7 +145,8 @@ module IDL
         yield # block should yield default content
       elsif default_content = options[:default_content]
         default_content = (Array === default_content) ? default_content : default_content.to_s.split("\n")
-        self << (default_content.collect {|l| (s = indent.dup) << l << "\n"; s }.join) unless default_content.empty?
+        self << (default_content.collect { |l| (s = indent.dup) << l << "\n"
+ s }.join) unless default_content.empty?
       end
       if options[:header]
         self << indent << regen_header_end_marker(sectionid) << "\n"
@@ -155,6 +157,7 @@ module IDL
 
     def save
       return if @options[:output_file]
+
       if @fout
         fgen = @fout
         @fout = nil
@@ -197,6 +200,7 @@ module IDL
 
     def remove
       return if @options[:output_file]
+
       if @fout
         begin
           @fout.close(true)
@@ -225,16 +229,19 @@ module IDL
             case $1
             when 'BEGIN'
               raise "ERROR: Found unterminated regeneration section starting at #{@path}:#{in_section.last}." if in_section
+
               in_section = [$2, linenr]
               section = []
             when 'END'
               raise "ERROR: Found unmatched regeneration end at #{@path}:#{linenr}." unless in_section && ($2 == in_section.first)
+
               sections[$2] = section
               in_section = nil
               section = []
             when 'HEADER_END'
               raise "ERROR: Found illegal header end marker at #{@path}:#{linenr}." unless _keep_header && in_section &&
-                                                                                                         ('HEADER' == in_section.first ) && (0 == in_section.last)
+                                                                                                         ('HEADER' == in_section.first ) && (in_section.last.zero?)
+
               sections[$2] = section
               in_section = nil
               section = []
@@ -249,6 +256,5 @@ module IDL
       sections[in_section.first] = section if in_section
       @content = Content.new(sections)
     end
-
   end
-end
+end