riddl 0.99.105

data/lib/riddl/wrapper/description/resource.rb

@@ -0,0 +1,271 @@
+module Riddl
+  class Wrapper
+    class Description < WrapperUtils
+      
+      class Resource
+        def initialize(path=nil,recursive=false)
+          #{{{
+          @path = path
+          @role = nil
+          @resources = {}
+          @access_methods = {}
+          @composition = {}
+          @recursive = recursive
+          #}}}
+        end
+
+        def add_access_methods(des,desres,index,interface)
+          #{{{
+          desres.find("des:*[not(name()='resource') and not(name()='websocket') and @in and not(@in='*')]").each do |m|
+            method = m.attributes['method'] || m.qname.name
+            add_request_in_out(index,interface,des,method,m.attributes['in'],m.attributes['out'])
+          end
+          desres.find("des:*[not(name()='resource') and not(name()='websocket') and @pass and not(@pass='*')]").each do |m|
+            method = m.attributes['method'] || m.qname.name
+            add_request_in_out(index,interface,des,method,m.attributes['pass'],m.attributes['pass'])
+          end
+          desres.find("des:*[not(name()='resource') and not(name()='websocket') and @transformation]").each do |m|
+            method = m.attributes['method'] || m.qname.name
+            add_request_transform(index,interface,des,method,m.attributes['transformation'])
+          end
+          desres.find("des:*[not(name()='resource') and not(name()='websocket') and @in and @in='*']").each do |m|
+            method = m.attributes['method'] || m.qname.name
+            add_request_star_out(index,interface,des,method,m.attributes['out'])
+          end
+          desres.find("des:*[not(name()='resource') and not(name()='websocket') and not(@in)]").each do |m|
+            method = m.attributes['method'] || m.qname.name
+            add_request_star_out(index,interface,des,method,m.attributes['out'])
+          end
+          desres.find("des:*[not(name()='resource') and not(name()='websocket') and @pass and @pass='*']").each do |m|
+            method = m.attributes['method'] || m.qname.name
+            add_request_pass(index,interface,method)
+          end
+          desres.find("des:*[not(name()='resource') and name()='websocket']").each do |m|
+            add_websocket(index,interface)
+          end
+          @role = desres.find("string(@role)")
+          @role = nil if @role.strip == ''
+          #}}}
+        end
+
+        # TODO add websockets
+
+        def remove_access_methods(des,filter)
+          #{{{
+          freq = if filter['in'] && filter['in'] != '*'
+            t = [RequestInOut,Riddl::Wrapper::Description::Message.new(des,filter['in'])]
+            t << (filter['out'] ? Riddl::Wrapper::Description::Message.new(des,filter['out']) : nil)
+          elsif filter['pass'] && filter['pass'] != '*'
+            [RequestInOut,Riddl::Wrapper::Description::Message.new(des,filter['pass']),Riddl::Wrapper::Description::Message.new(des,filter['pass'])]
+          elsif filter['in'] && filter['in'] == '*'
+            t = [RequestStarOut]
+            t << (filter['out'] ? Riddl::Wrapper::Description::Message.new(des,filter['out']) : nil)
+          elsif filter['transformation']
+            [RequestTransformation,Riddl::Wrapper::Description::Transformation.new(des,filter['transformation'])]
+          elsif filter['pass'] && filter['pass'] == '*'
+            [RequestPass]
+          end
+          raise BlockError, "blocking #{filter.inspect} not possible" if freq.nil?
+
+          if reqs = @access_methods[filter['method']]
+            reqs = reqs.last # current layer
+            reqs.delete_if do |req|
+              if req.class == freq[0]
+                if req.class == RequestInOut
+                  if freq[1] && freq[1].hash == req.in.hash && freq[2] && req.out && freq[2].hash == req.out.hash
+                    true
+                  elsif freq[1] && freq[1].hash == req.in.hash && !freq[2]
+                    true
+                  end
+                elsif req.class == RequestStarOut
+                  true if freq[1] && req.out && freq[1].hash == req.out.hash
+                elsif req.class == RequestTransformation
+                  true if freq[1] && freq[1].hash == req.trans.hash
+                elsif req.class == RequestPass
+                  true
+                end
+              end  
+            end
+          end  
+          #}}}
+        end
+
+        def compose!
+          #{{{
+          @access_methods.each do |k,v|
+            ### remove all emtpy layers  
+            v.compact!
+            case v.size
+              when 0
+              when 1
+                @composition[k] = compose_plain(v[0])
+              else
+                @composition[k] = compose_layers(k,v)
+            end
+          end  
+          #}}}
+        end
+        
+        def compose_layers(k,layers)
+          #{{{
+          routes = []
+          layers[0].find_all{|l|l.class==RequestInOut}.each do |r|
+            traverse_layers(container = [[r]],container[0],layers,1) unless r.used?
+            routes += container unless container.nil?
+          end
+          layers[0].find_all{|l|l.class==RequestTransformation}.each do |r|
+            traverse_layers(container = [[r]],container[0],layers,1) unless r.used?
+            routes += container unless container.nil?
+          end
+          layers[0].find_all{|l|l.class==RequestStarOut}.each do |r|
+            traverse_layers(container = [[r]],container[0],layers,1) unless r.used?
+            routes += container unless container.nil?
+          end
+          layers[0].find_all{|l|l.class==RequestPass}.each do |r|
+            traverse_layers(container = [[r]],container[0],layers,1) unless r.used?
+            routes += container unless container.nil?
+          end
+          routes.map do |r|
+            ret = nil
+            teh_last = r.last
+            begin
+              success = true
+              if r.first.respond_to?(:in) && teh_last.respond_to?(:out)
+                #1: responds first in + last out -> new InOut
+                ret = RequestInOut.new_from_message(r.first.in,teh_last.out)
+              elsif r.first.class == RequestTransformation && teh_last.class == RequestTransformation && teh_last.out.nil?
+                #2: first transform + last transform -> merge transformations
+                ret = RequestTransformation.new_from_transformation(r.first.trans,teh_last.trans)
+              elsif teh_last.respond_to?(:out)
+                #3: responds last out only -> new StarOut
+                ret = RequestStarOut.new_from_message(teh_last.out)
+              elsif teh_last.class == RequestPass
+                #4: last pass -> remove last until #1 or #2 or #3 or size == 1
+                if r.size > 1
+                  teh_last = r[-2]
+                  success = false
+                else 
+                  ret = teh_last
+                end  
+              end
+            end while !success
+            Composition.new(r,ret)
+          end
+          #}}}
+        end
+        private :compose_layers
+
+        def compose_plain(access_method)
+          #{{{
+          access_method.map do |ret|
+            Composition.new(nil,ret)
+          end
+          #}}}
+        end
+        private :compose_plain
+        
+        def traverse_layers(container,path,layers,layer)
+          #{{{
+          return if layers.count <= layer
+          current = path.last
+          current_path = path.dup 
+
+          # messages RequestInOut and RequestStarOut with no out are not processed
+          return if ((current.class == RequestInOut || current.class == RequestStarOut) && current.out.nil?)
+
+          if current.class == RequestInOut || 
+            (current.class == RequestTransformation && !current.out.nil?) || 
+             current.class == RequestStarOut
+            # Find all where "in" matches
+            layers[layer].find_all{ |l| (l.class == RequestInOut && l.in.traverse?(current.out) && !l.used?) }.each do |r|
+              path << r
+              path.last.used = true
+              traverse_layers(container,path,layers,layer+1)
+              return
+            end
+            # Find all possible transformations and apply them
+            layers[layer].find_all{ |l| l.class == RequestTransformation }.each_with_index do |r,num|
+              if num > 0
+                path = current_path.dup
+                container << path
+              end  
+              path << r.transform(current)
+              r.used = true
+              traverse_layers(container,path,layers,layer+1)
+            end
+            # Find all in=* matches, they are all potential matches, even when used
+            layers[layer].find_all{ |l| l.class == RequestPass || l.class == RequestStarOut }.each_with_index do |r,num|
+              add_to_path_and_split(container,path,layers,layer,num,current_path,r)
+            end
+            return
+          end  
+
+          if (current.class == RequestTransformation && current.out.nil?) ||
+              current.class == RequestPass
+            # all unused RequestInOut and all others (even if used)
+            layers[layer].find_all{|l| (l.class == RequestInOut && !l.used?) || (l.class != RequestInOut) }.each_with_index do |r,num|
+              add_to_path_and_split(container,path,layers,layer,num,current_path,r)
+            end
+          end  
+        #}}}
+        end
+        private :traverse_layers
+
+        def add_to_path_and_split(container,path,layers,layer,num,current_path,r)
+          #{{{
+          if num > 0
+            path = current_path.dup
+            container << path
+          end  
+          path << r
+          path.last.used = true
+          traverse_layers(container,path,layers,layer+1)
+          #}}}
+        end
+        private :add_to_path_and_split
+
+        # add requests helper methods
+        #{{{
+        def add_request_in_out(index,interface,des,method,min,mout)
+          @access_methods[method] ||= []
+          @access_methods[method][index] ||= []
+          @access_methods[method][index] << RequestInOut.new(des,min,mout,interface)
+        end
+        private :add_request_in_out
+
+        def add_request_transform(index,interface,des,method,mtrans)
+          @access_methods[method] ||= []
+          @access_methods[method][index] ||= []
+          @access_methods[method][index] << RequestTransformation.new(des,mtrans,interface)
+        end
+        private :add_request_transform
+
+        def add_request_star_out(index,interface,des,method,mout)
+          @access_methods[method] ||= []
+          @access_methods[method][index] ||= []
+          @access_methods[method][index] << RequestStarOut.new(des,mout,interface)
+        end
+        private :add_request_star_out
+
+        def add_request_pass(index,interface,method)
+          @access_methods[method] ||= []
+          @access_methods[method][index] ||= []
+          @access_methods[method][index] << RequestPass.new(interface)
+        end
+        private :add_request_pass
+        
+        def add_websocket(index,interface)
+          @access_methods['websocket'] ||= []
+          @access_methods['websocket'][index] ||= []
+          @access_methods['websocket'][index] << WebSocket.new(interface)
+        end
+        private :add_request_pass
+        #}}}
+
+        attr_reader :resources,:path,:access_methods,:composition,:recursive,:role
+      end
+
+      Composition = Struct.new(:route,:result)
+    end
+  end
+end

data/lib/riddl/wrapper/layerchecker.rb

@@ -0,0 +1,33 @@
+module Riddl
+  class Wrapper
+    class LayerChecker
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def check
+        check_layers(@doc.find("/dec:declaration/dec:facade/dec:tile/dec:layer"))
+      end
+
+      def check_layers(res)
+        #{{{
+        messages = []
+        res.each do |res|
+          messages += check_field(res.attributes['name'],res.parent.attributes['relative'] || '/')
+        end
+        messages
+        #}}}
+      end
+      private :check_layers
+
+      def check_field(name,tile)
+        #{{{
+        if @doc.find("/dec:declaration/dec:interface[@name='#{name}']").empty?
+          ["Tile '#{tile}': interface '#{name}' not found."]
+        end || []
+        #}}}
+      end
+      private :check_field
+    end
+  end
+end

data/lib/riddl/wrapper/messageparser.rb

@@ -0,0 +1,221 @@
+module Riddl
+  class Wrapper
+    class MessageParser
+      def initialize(params,headers)
+        #{{{
+        @mist = params
+        @mistp = 0
+        @headp = {}
+        headers.each do |k,v|
+          if v.nil?
+            @headp[k.name.upcase.gsub(/\-/,'_')] = k.value
+          else  
+            @headp[k.upcase.gsub(/\-/,'_')] = v
+          end  
+        end
+
+        @numparams = 0
+        #}}}
+      end
+
+      def check(what,ignore_name=false)
+        #{{{
+        # reset for subsequent calls
+        @mistp = 0
+        @numparams = 0
+
+        # out not available
+        return true if what.nil? && @mist.empty?
+
+        # do it
+        m  = what.content.root
+
+        m.find("des:header").each do |h|
+          return false unless header h
+        end
+
+        if ignore_name
+          # if only one parameter, ignore the name
+          @numparams = m.find("count(//des:parameter)").to_i
+        end  
+
+        m.find("des:*[not(name()='header')]").each do |p|
+          return false unless send p.qname.to_s, p
+        end
+
+        @mist.count == @mistp
+        #}}}
+      end
+
+      def parameter(a)
+        #{{{
+        return false if @mistp >= @mist.length
+        b = @mist[@mistp]
+
+        if b.class == Riddl::Parameter::Simple && (a.attributes['fixed'] || a.attributes['type'])
+          b.name = a.attributes['name'] if @numparams == 1
+          if (b.name == a.attributes['name'] || a.attributes['name'] == '*')
+            @mistp += 1
+            return match_simple(a,b.value)
+          end
+        end
+        if b.class == Riddl::Parameter::Complex && a.attributes['mimetype']
+          b.name = a.attributes['name'] if @numparams == 1
+          if (b.name == a.attributes['name'] || a.attributes['name'] == '*') && match_mimetype(a,b)
+            if a.attributes['handler']
+              if Riddl::Handlers::handlers[a.attributes['handler']]
+                success = Riddl::Handlers::handlers[a.attributes['handler']].handle(b.value,a.children.map{|e|e.dump}.join)
+                b.value.rewind if b.value.respond_to?(:rewind)
+                if success
+                  @mistp += 1
+                  return true
+                end  
+              else
+                # handler not found leads to an error
+                return false
+              end  
+            else
+              @mistp += 1
+              return true
+            end  
+          end
+        end  
+        false
+        #}}}
+      end
+      private :parameter
+      
+      def oneOrMore(a)
+        #{{{
+        tistp = @mistp
+        ncounter = 0
+        begin
+          counter,length = traverse_simple(a,true)
+          ncounter += 1 if counter == length
+        end while counter == length && @mistp < @mist.length
+        if ncounter > 0 
+          true
+        else  
+          @mistp = tistp
+          false
+        end  
+        #}}}
+      end
+
+      def zeroOrMore(a)
+        #{{{
+        begin
+          counter,length = traverse_simple(a,true)
+        end while counter == length && @mistp < @mist.length 
+        true
+        #}}}
+      end
+
+      def choice(a)
+        #{{{
+        a.find("des:*").each do |p|
+          return true if send p.qname.to_s, p
+        end
+        false
+        #}}}
+      end  
+      
+      def group(a)
+        #{{{
+        tistp = @mistp
+        success = true
+        a.find("des:*").each do |p|
+          unless send p.qname.to_s, p
+            success = false
+            break
+          end
+        end
+        if success
+          true
+        else  
+          @mistp = tistp
+          false
+        end  
+        #}}}
+      end  
+
+      def optional(a)
+        #{{{
+        return true if @mistp >= @mist.length
+
+        tistp = @mistp
+        counter, length = traverse_simple(a,true)
+
+        if counter == 0 || counter == length
+          true
+        else  
+          @mistp = tistp
+          false
+        end
+        #}}}
+      end
+
+      def header(a)
+        #{{{
+        name = a.attributes['name'].upcase.sub(/\-/,'_')
+        if @headp[name]
+          return match_simple(a,@headp[name])
+        end
+        false
+        #}}}
+      end
+      private :header
+
+      def traverse_simple(a,single_optional_protection=false)
+        #{{{
+        tistp = @mistp
+        nodes = a.find("des:*")
+        counter = 0
+        lastname = ''
+        nodes.each do |p|
+          lastname = p.qname.to_s 
+          counter += 1 if send lastname, p
+        end
+        if single_optional_protection && lastname == 'optional' && tistp == @mistp
+          [0,-1]
+        else  
+          [counter,nodes.length]
+        end 
+        #}}}
+      end
+      
+      def match_simple(a,b)
+        #{{{
+        if a.attributes['fixed']
+          a.attributes['fixed'] == b
+        else  
+          value = XML::Smart::string("<check/>")
+          value.root.text = b
+          type = XML::Smart::string(CHECK)
+          data = type.root.children[0]
+          data.attributes['type'] = a.attributes['type']
+          data.add a.children
+          value.validate_against type
+        end  
+        #}}}
+      end
+      private :match_simple
+
+      def match_mimetype(a,b)
+        if (a.attributes['mimetype'] == '*' || b.mimetype == a.attributes['mimetype'])
+          true
+        else
+          ma = a.attributes['mimetype'].split('/')
+          mb = b.mimetype.split('/')
+          if ma.length == 2 && mb.length == 2 && ((ma[0] == mb[0] && ma[1] == '*') || (ma[1] == mb[1] && ma[0] == '*'))
+            true
+          else
+            false
+          end  
+        end
+      end
+      private :match_mimetype
+
+    end  
+  end    
+end