norikra 0.0.6-java → 0.0.7-java

data/Rakefile

@@ -1,7 +1,7 @@
 require "bundler/gem_tasks"
 
 require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:test) do |t|
+RSpec::Core::RakeTask.new(:spec) do |t|
   t.rspec_opts = ["-c", "-f progress"] # '--format specdoc'
   t.pattern = 'spec/**/*_spec.rb'
 end

data/lib/norikra/engine.rb

@@ -1,5 +1,7 @@
 require 'java'
 
+require 'norikra/error'
+
 require 'norikra/logger'
 include Norikra::Log
 
@@ -33,11 +35,15 @@ module Norikra
     end
 
     def start
+      debug "norikra engine starting: creating esper runtime"
       @runtime = @service.getEPRuntime
+      debug "norikra engine started"
     end
 
     def stop
-      #TODO: stop to @runtime
+      debug "stopping norikra engine: stop all statements on esper"
+      @service.getEPAdministrator.stopAllStatements
+      debug "norikra engine stopped"
     end
 
     def open(target, fields=nil)
@@ -48,8 +54,11 @@ module Norikra
 
     def close(target)
       info "closing target", :target => target
-      #TODO: write
-      raise NotImplementedError
+      return false unless @targets.include?(target)
+      @queries.select{|q| q.targets.include?(target)}.each do |query|
+        deregister_query(query)
+      end
+      close_target(target)
     end
 
     def reserve(target, field, type)
@@ -58,6 +67,8 @@ module Norikra
 
     def register(query)
       info "registering query", :name => query.name, :targets => query.targets, :expression => query.expression
+      raise Norikra::ClientError, "query name '#{query.name}' already exists" if @queries.select{|q| q.name == query.name }.size > 0
+
       query.targets.each do |target|
         open(target) unless @targets.include?(target)
       end
@@ -66,8 +77,10 @@ module Norikra
 
     def deregister(query_name)
       info "de-registering query", :name => query_name
-      #TODO: write
-      raise NotImplementedError
+      queries = @queries.select{|q| q.name == query_name }
+      return nil unless queries.size == 1 # just ignore for 'not found'
+
+      deregister_query(queries.first)
     end
 
     def send(target, events)
@@ -81,11 +94,9 @@ module Norikra
       if @typedef_manager.lazy?(target)
         info "opening lazy target", :target => target
         debug "generating base fieldset from event", :target => target, :event => events.first
-
         base_fieldset = @typedef_manager.generate_base_fieldset(target, events.first)
 
         debug "registering base fieldset", :target => target, :base => base_fieldset
-
         register_base_fieldset(target, base_fieldset)
 
         info "target successfully opened with fieldset", :target => target, :base => base_fieldset
@@ -99,10 +110,11 @@ module Norikra
         unless registered_data_fieldset[fieldset.summary]
           # register waiting queries including this fieldset, and this fieldset itself
           debug "registering unknown fieldset", :target => target, :fieldset => fieldset
-
           register_fieldset(target, fieldset)
-
           debug "successfully registered"
+
+          # fieldset should be refined, when waiting_queries rewrite inheritance structure and data fieldset be renewed.
+          fieldset = @typedef_manager.refer(target, event)
         end
 
         trace "calling sendEvent", :target => target, :fieldset => fieldset, :event_type_name => fieldset.event_type_name, :event => event
@@ -136,9 +148,9 @@ module Norikra
     private
 
     def open_target(target, fields)
-      # from open
       @mutex.synchronize do
         return false if @targets.include?(target)
+
         @typedef_manager.add_target(target, fields)
         @registered_fieldsets[target] = {:base => {}, :query => {}, :data => {}}
 
@@ -154,6 +166,18 @@ module Norikra
       true
     end
 
+    def close_target(target)
+      @mutex.synchronize do
+        return false unless @targets.include?(target)
+
+        @typedef_manager.remove_target(target)
+        @registered_fieldsets.delete(target)
+
+        @targets.delete(target)
+      end
+      true
+    end
+
     def register_base_fieldset(target, fieldset)
       # for lazy target, with generated fieldset from sent events.first
       @mutex.synchronize do
@@ -162,11 +186,24 @@ module Norikra
         @typedef_manager.activate(target, fieldset)
         register_fieldset_actually(target, fieldset, :base)
       end
-      nil
+      true
+    end
+
+    def update_inherits_graph(target, query_fieldset)
+      # replace registered data fieldsets with new fieldset inherits this query fieldset
+      @typedef_manager.supersets(target, query_fieldset).each do |set|
+        rebound = set.rebind(true) # update event_type_name with new inheritations
+
+        register_fieldset_actually(target, rebound, :data, true) # replacing on esper engine
+        @typedef_manager.replace_fieldset(target, set, rebound)
+        deregister_fieldset_actually(target, set.event_type_name, :data)
+      end
     end
 
     def register_query(query)
       @mutex.synchronize do
+        raise Norikra::ClientError, "query '#{query.name}' already exists" unless @queries.select{|q| q.name == query.name }.empty?
+
         unless @typedef_manager.ready?(query)
           @waiting_queries.push(query)
           @queries.push(query)
@@ -177,22 +214,36 @@ module Norikra
         mapping.each do |target, query_fieldset|
           @typedef_manager.bind_fieldset(target, :query, query_fieldset)
           register_fieldset_actually(target, query_fieldset, :query)
+          update_inherits_graph(target, query_fieldset)
+          query.fieldsets[target] = query_fieldset
         end
+
         register_query_actually(query, mapping)
+        @queries.push(query)
+      end
+      true
+    end
 
-        mapping.each do |target, query_fieldset|
-          # replace registered data fieldsets with new fieldset inherits this query fieldset
-          @typedef_manager.supersets(target, query_fieldset).each do |set|
-            rebound = set.rebind(true) # update event_type_name with new inheritations
+    def deregister_query(query)
+      @mutex.synchronize do
+        return nil unless @queries.include?(query)
+
+        deregister_query_actually(query)
+        @queries.delete(query)
 
-            register_fieldset_actually(target, rebound, :data, true) # replacing
-            @typedef_manager.replace_fieldset(target, set, rebound)
-            remove_fieldset_actually(target, set, :data)
+        if @waiting_queries.include?(query)
+          @waiting_queries.delete(query)
+        else
+          query.fieldsets.each do |target, query_fieldset|
+            removed_event_type_name = query_fieldset.event_type_name
+
+            @typedef_manager.unbind_fieldset(target, :query, query_fieldset)
+            update_inherits_graph(target, query_fieldset)
+            deregister_fieldset_actually(target, removed_event_type_name, :query)
           end
         end
-
-        @queries.push(query)
       end
+      true
     end
 
     def register_waiting_queries(target)
@@ -212,6 +263,8 @@ module Norikra
         mapping.each do |target, query_fieldset|
           @typedef_manager.bind_fieldset(target, :query, query_fieldset)
           register_fieldset_actually(target, query_fieldset, :query)
+          update_inherits_graph(target, query_fieldset)
+          query.fieldsets[target] = query_fieldset
         end
         register_query_actually(query, mapping)
       end
@@ -244,6 +297,19 @@ module Norikra
 
       epl = administrator.create(statement_model)
       epl.java_send :addListener, [com.espertech.esper.client.UpdateListener.java_class], Listener.new(query.name, @output_pool)
+      query.statement_name = epl.getName
+      # epl is automatically started.
+      # epl.isStarted #=> true
+    end
+
+    # this method should be protected with @mutex lock
+    def deregister_query_actually(query)
+      administrator = @service.getEPAdministrator
+      epl = administrator.getStatement(query.statement_name)
+      return unless epl
+
+      epl.stop unless epl.isStopped
+      epl.destroy unless epl.isDestroyed
     end
 
     # this method should be protected with @mutex lock
@@ -273,13 +339,13 @@ module Norikra
     end
 
     # this method should be protected with @mutex lock as same as register
-    def remove_fieldset_actually(target, fieldset, level)
-      return if level == :base || level == :query
+    def deregister_fieldset_actually(target, event_type_name, level)
+      return if level == :base
 
       # DON'T check @registered_fieldsets[target][level][fieldset.summary]
       # removed fieldset should be already replaced with register_fieldset_actually w/ replace flag
-      debug "remove event type", :target => target, :event_type => fieldset.event_type_name
-      @config.removeEventType(fieldset.event_type_name, true)
+      debug "remove event type", :target => target, :event_type => event_type_name
+      @config.removeEventType(event_type_name, true)
     end
   end
 end

data/lib/norikra/error.rb

@@ -0,0 +1,5 @@
+module Norikra
+  class ClientError < StandardError; end
+  class ArgumentError < ClientError; end
+  class QueryError < ClientError; end
+end

data/lib/norikra/query.rb

@@ -4,15 +4,18 @@ require 'esper/lib/commons-logging-1.1.1.jar'
 require 'esper/lib/antlr-runtime-3.2.jar'
 require 'esper/lib/cglib-nodep-2.2.jar'
 
+require 'norikra/error'
 require 'norikra/query/ast'
 
 module Norikra
   class Query
-    attr_accessor :name, :expression
+    attr_accessor :name, :expression, :statement_name, :fieldsets
 
     def initialize(param={})
       @name = param[:name]
       @expression = param[:expression]
+      @statement_name = nil
+      @fieldsets = {} # { target => fieldset }
       @ast = nil
       @targets = nil
       @subqueries = nil
@@ -56,13 +59,17 @@ module Norikra
       all = []
       unknowns = []
       self.ast.listup(:stream).each do |node|
-        #TODO: raise error for same name of target/alias
         if node.alias
           alias_map[node.alias] = node.target
         end
         fields[node.target] = []
       end
 
+      dup_aliases = (alias_map.keys & fields.keys)
+      unless dup_aliases.empty?
+        raise Norikra::ClientError, "Invalid alias '#{dup_aliases.join(',')}', same with target name"
+      end
+
       default_target = fields.keys.size == 1 ? fields.keys.first : nil
 
       outer_targets.each do |t|
@@ -81,7 +88,7 @@ module Norikra
         if field_def[:t]
           t = alias_map[field_def[:t]] || field_def[:t]
           unless fields[t]
-            raise "unknown target alias name for: #{field_def[:t]}.#{field_def[:f]}"
+            raise Norikra::ClientError, "unknown target alias name for: #{field_def[:t]}.#{field_def[:f]}"
           end
           fields[t].push(f)
 
@@ -125,7 +132,6 @@ module Norikra
     end
 
     def ast
-      #TODO: take care for parse error(com.espertech.esper.client.EPStatementSyntaxException)
       return @ast if @ast
       rule = ParseRuleSelectorImpl.new
       target = @expression.dup
@@ -134,6 +140,8 @@ module Norikra
 
       @ast = astnode(result.getTree)
       @ast
+    rescue Java::ComEspertechEsperClient::EPStatementSyntaxException => e
+      raise Norikra::QueryError, e.message
     end
 
     def self.rewrite_event_type_name(statement_model, mapping)

data/lib/norikra/rpc.rb

@@ -1,5 +1,8 @@
+require 'msgpack-rpc-over-http-jruby'
+
 module Norikra::RPC
-  # namespace only
+  class ClientError < MessagePack::RPCOverHTTP::RemoteError; end
+  class ServerError < MessagePack::RPCOverHTTP::RemoteError; end
 end
 
 require 'norikra/rpc/handler'

data/lib/norikra/rpc/handler.rb

@@ -1,6 +1,9 @@
+require 'norikra/error'
 require 'norikra/logger'
 include Norikra::Log
 
+require 'norikra/rpc'
+
 class Norikra::RPC::Handler
   def initialize(engine)
     @engine = engine
@@ -15,12 +18,15 @@ class Norikra::RPC::Handler
 
     begin
       yield
+    rescue Norikra::ClientError => e
+      info "ClientError #{e.class}: #{e.message}"
+      raise Norikra::RPC::ClientError, e.message
     rescue => e
       error "Exception #{e.class}: #{e.message}"
       e.backtrace.each do |t|
         error "  " + t
       end
-      nil
+      raise Norikra::RPC::ServerError, "#{e.class}, #{e.message}"
     end
   end
 
@@ -59,8 +65,8 @@ class Norikra::RPC::Handler
 
   def deregister(query_name)
     logging(:manage, :deregister, query_name){
-      #TODO: write!
-      raise NotImplementedError
+      r = @engine.deregister(query_name)
+      !!r
     }
   end
 

data/lib/norikra/server.rb

@@ -35,11 +35,15 @@ module Norikra
       info "Norikra server started."
       @running = true
 
-      Signal.trap(:INT){ @running = false }
-      #TODO: more signal traps (dumps of query/fields? or other handler?)
+      shutdown_proc = ->{ @running = false }
+      # JVM uses SIGQUIT for thread/heap state dumping
+      [:INT, :TERM].each do |s|
+        Signal.trap(s, shutdown_proc)
+      end
+      #TODO: SIGHUP? SIGUSR1? SIGUSR2? (dumps of query/fields? or other handler?)
 
       while @running
-        sleep 1
+        sleep 0.3
       end
     end
 

data/lib/norikra/typedef.rb

@@ -1,6 +1,8 @@
 require 'digest'
 require 'json'
 
+require 'norikra/error'
+
 # Norikra::Field, Norikra::FieldSet, Norikra::Typedef
 
 module Norikra
@@ -53,7 +55,7 @@ module Norikra
       when 'float' then 'float'
       when 'double' then 'double'
       else
-        raise ArgumentError, "invalid field type #{type}"
+        raise Norikra::ArgumentError, "invalid field type #{type}"
       end
     end
 
@@ -99,8 +101,21 @@ module Norikra
       self.class.new(fields, nil, @rebounds)
     end
 
-    def self.field_names_key(data)
-      data.keys.sort.join(',')
+    def self.field_names_key(data, fieldset=nil)
+      if fieldset
+        keys = []
+        fieldset.fields.each do |key,field|
+          unless field.optional?
+            keys.push(key)
+          end
+        end
+        data.keys.each do |key|
+          keys.push(key) unless keys.include?(key)
+        end
+        keys.sort.join(',')
+      else
+        data.keys.sort.join(',')
+      end
     end
 
     def field_names_key
@@ -217,7 +232,7 @@ module Norikra
       @queryfieldsets = []
       @datafieldsets = []
 
-      @set_map = {} # FieldSet.field_names_key(data_fieldset) => data_fieldset
+      @set_map = {} # FieldSet.field_names_key(data_fieldset, fieldset) => data_fieldset
 
       @mutex = Mutex.new
     end
@@ -259,7 +274,7 @@ module Norikra
 
     def push(level, fieldset)
       unless self.consistent?(fieldset)
-        raise ArgumentError, "inconsistent field set for this typedef"
+        raise Norikra::ArgumentError, "field definition mismatch with already defined fields"
       end
 
       @mutex.synchronize do
@@ -292,9 +307,25 @@ module Norikra
       true
     end
 
+    def pop(level, fieldset)
+      @mutex.synchronize do
+        case level
+        when :base
+          raise RuntimeError, "BUG: pop of base fieldset is nonsense (typedef deletion?)"
+        when :query
+          @queryfieldsets.delete(fieldset) if @queryfieldsets.include?(fieldset)
+        when :data
+          raise RuntimeError, "BUG: pop of data fieldset is nonsense"
+        else
+          raise ArgumentError, "unknown level #{level}"
+        end
+      end
+      true
+    end
+
     def replace(level, old_fieldset, fieldset)
       unless self.consistent?(fieldset)
-        raise ArgumentError, "inconsistent field set for this typedef"
+        raise Norikra::ArgumentError, "field definition mismatch with already defined fields"
       end
       if level != :data
         raise ArgumentError, "invalid argument, fieldset replace should be called for :data"
@@ -311,7 +342,7 @@ module Norikra
     end
 
     def refer(data)
-      field_names_key = FieldSet.field_names_key(data)
+      field_names_key = FieldSet.field_names_key(data, self)
       return @set_map[field_names_key] if @set_map.has_key?(field_names_key)
 
       guessed = FieldSet.simple_guess(data)
@@ -319,11 +350,12 @@ module Norikra
       @fields.each do |key,field|
         if guessed_fields.has_key?(key)
           guessed_fields[key].type = field.type if guessed_fields[key].type != field.type
+          guessed_fields[key].optional = field.optional if guessed_fields[key].optional != field.optional
         else
           guessed_fields[key] = field unless field.optional?
         end
       end
-      guessed
+      guessed.update_summary
     end
 
     def format(data)

data/lib/norikra/typedef_manager.rb

@@ -1,6 +1,7 @@
 require 'digest'
 
 require 'norikra/typedef'
+require 'norikra/error'
 
 module Norikra
   class TypedefManager
@@ -19,11 +20,18 @@ module Norikra
       # fields nil || [] => lazy
       # fields {'fieldname' => 'type'}
       @mutex.synchronize do
-        raise RuntimeError, "target #{target} already exists" if @typedefs[target]
+        raise Norikra::ArgumentError, "target '#{target}' already exists" if @typedefs[target]
         @typedefs[target] = Typedef.new(fields)
       end
     end
 
+    def remove_target(target)
+      @mutex.synchronize do
+        raise Norikra::ArgumentError, "target '#{target}' doesn't exists" unless @typedefs[target]
+        @typedefs.delete(target)
+      end
+    end
+
     def lazy?(target)
       @typedefs[target].lazy?
     end
@@ -48,14 +56,14 @@ module Norikra
 
     def generate_fieldset_mapping(query)
       fields_set = {}
+
       query.targets.each do |target|
         fields_set[target] = query.fields(target)
       end
       query.fields(nil).each do |field|
         assumed = query.targets.select{|t| @typedefs[t].field_defined?([field])}
         if assumed.size != 1
-          #TODO exception class
-          raise "cannot determine target for field #{field}"
+          raise Norikra::ClientError, "cannot determine target for field '#{field}' in this query"
         end
         fields_set[assumed.first].push(field)
       end
@@ -64,7 +72,6 @@ module Norikra
       fields_set.each do |target,fields|
         mapping[target] = generate_query_fieldset(target, fields.sort.uniq)
       end
-
       mapping
     end
 
@@ -73,6 +80,10 @@ module Norikra
       @typedefs[target].push(level, fieldset)
     end
 
+    def unbind_fieldset(target, level, fieldset)
+      @typedefs[target].pop(level, fieldset)
+    end
+
     def replace_fieldset(target, old_fieldset, new_fieldset)
       @typedefs[target].replace(:data, old_fieldset, new_fieldset)
     end

data/lib/norikra/version.rb

@@ -1,3 +1,3 @@
 module Norikra
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/field_spec.rb

@@ -1,6 +1,7 @@
 require_relative './spec_helper'
 
 require 'norikra/typedef'
+# require 'norikra/error'
 
 require 'json'
 require 'digest'
@@ -22,7 +23,7 @@ describe Norikra::Field do
     end
 
     it 'raises ArgumentError for unknown type string' do
-      expect { Norikra::Field.valid_type?('foo') }.to raise_error(ArgumentError)
+      expect { Norikra::Field.valid_type?('foo') }.to raise_error()
     end
   end
 

data/spec/fieldset_spec.rb

@@ -75,6 +75,10 @@ describe Norikra::FieldSet do
       it 'returns comma-separated sorted field names of argument hash' do
         expect(Norikra::FieldSet.field_names_key({'x1'=>1,'y3'=>2,'xx'=>3,'xx1'=>4,'a'=>5})).to eql('a,x1,xx,xx1,y3')
       end
+
+      it 'returns comma-separated sorted field names of argument hash AND non-optional fields of 2nd argument fieldset instance' do
+        expect(Norikra::FieldSet.field_names_key({'x1'=>1,'y3'=>2,'xx'=>3,'xx1'=>4}, set)).to eql('a,x,x1,xx,xx1,y,y3')
+      end
     end
 
     describe '#field_names_key' do

data/spec/typedef_manager_spec.rb

@@ -127,12 +127,15 @@ describe Norikra::TypedefManager do
       end
     end
 
-    describe '#bind_fieldset' do
+    describe '#bind_fieldset and #unbind_fieldset' do
       it 'does not fail' do
         manager.bind_fieldset('sample', :query, set_query_base)
         expect(set_query_base.target).to eql('sample')
         expect(set_query_base.level).to eql(:query)
         expect(manager.typedefs['sample'].queryfieldsets.include?(set_query_base)).to be_true
+
+        manager.unbind_fieldset('sample', :query, set_query_base)
+        expect(manager.typedefs['sample'].queryfieldsets.include?(set_query_base)).to be_false
       end
     end
 
@@ -165,8 +168,7 @@ describe Norikra::TypedefManager do
         manager.bind_fieldset('sample', :query, set_f)
 
         list = manager.subsets('sample', Norikra::FieldSet.new(base.merge({'d'=>'string','e'=>'string','g'=>'string'})))
-        expect(list.size).to eql(4) # set_query_base, set_d, set_e, baseset
-        expect(list.include?(set_query_base)).to be_true
+        expect(list.size).to eql(3) # set_d, set_e, baseset
         expect(list.include?(set_d)).to be_true
         expect(list.include?(set_e)).to be_true
         expect(list.include?(set_f)).to be_false

data/spec/typedef_spec.rb

@@ -1,6 +1,7 @@
 require_relative './spec_helper'
 
 require 'norikra/typedef'
+# require 'norikra/error'
 
 require 'json'
 require 'digest'
@@ -158,16 +159,16 @@ describe Norikra::Typedef do
     describe '#push' do
       it 'does not accepts fieldset which conflicts pre-defined fields' do
         t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
-        expect { t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'int'})) }.to raise_error(ArgumentError)
-        expect { t.push(:data, Norikra::FieldSet.new({'a'=>'string'})) }.to raise_error(ArgumentError)
+        expect { t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'int'})) }.to raise_error(Norikra::ArgumentError)
+        expect { t.push(:data, Norikra::FieldSet.new({'a'=>'string'})) }.to raise_error(Norikra::ArgumentError)
       end
 
       it 'accepts fieldsets which is consistent with self' do
         t = Norikra::Typedef.new({'a'=>'string','b'=>'long'})
         expect(t.fields.size).to eql(2)
 
-        expect { t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long'})) }.not_to raise_error(ArgumentError)
-        expect { t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long'})) }.not_to raise_error(ArgumentError)
+        t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long'}))
+        t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long'}))
 
         expect(t.fields.size).to eql(2)
 
@@ -184,13 +185,36 @@ describe Norikra::Typedef do
       end
     end
 
+    describe '#pop' do
+      it 'does not accepts base/data fieldsets' do
+        t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+        expect { t.pop(:base, Norikra::FieldSet.new({'a'=>'string','b'=>'int'})) }.to raise_error(RuntimeError)
+        expect { t.pop(:data, Norikra::FieldSet.new({'a'=>'string'})) }.to raise_error(RuntimeError)
+      end
+
+      it 'removes specified query fieldset from queryfieldsets' do
+        t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+        set1 = Norikra::FieldSet.new({'a'=>'string','b' => 'long','c'=>'int'})
+        set2 = Norikra::FieldSet.new({'a'=>'string','b' => 'long'})
+        t.push(:query, set1)
+        t.push(:query, set2)
+
+        expect(t.queryfieldsets.size).to eql(2)
+
+        t.pop(:query, set1)
+        expect(t.queryfieldsets.size).to eql(1)
+        t.pop(:query, set2)
+        expect(t.queryfieldsets.size).to eql(0)
+      end
+    end
+
     describe '#replace' do
       it 'raises error for different field name sets' do
         t = Norikra::Typedef.new({'a'=>'string'})
         set1 = Norikra::FieldSet.new({'a'=>'string','b'=>'int'})
         set2 = Norikra::FieldSet.new({'a'=>'string','c'=>'int'})
         t.push(:data, set1)
-        expect { t.replace(:data, set1, set2) }.to raise_error(ArgumentError)
+        expect { t.replace(:data, set1, set2) }.to raise_error(Norikra::ArgumentError)
       end
 
       it 'replaces typedef internal fieldset object for specified field_names_key' do
@@ -235,6 +259,7 @@ describe Norikra::Typedef do
           expect(r.fields['b'].type).to eql('long')
           expect(r.fields['c'].type).to eql('boolean')
           expect(r.fields['d'].type).to eql('double')
+          expect(r.summary).to eql('a:string,b:long,c:boolean,d:double')
         end
       end
 
@@ -249,6 +274,7 @@ describe Norikra::Typedef do
           expect(r.fields['b'].type).to eql('long')
           expect(r.fields['c'].type).to eql('string')
           expect(r.fields['d'].type).to eql('string')
+          expect(r.summary).to eql('a:string,b:long,c:string,d:string')
         end
       end
     end

metadata

@@ -2,14 +2,14 @@
 name: norikra
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.0.6
+  version: 0.0.7
 platform: java
 authors:
 - TAGOMORI Satoshi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-07-05 00:00:00.000000000 Z
+date: 2013-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mizuno
@@ -262,12 +262,14 @@ files:
 - lib/norikra.rb
 - lib/norikra/cli.rb
 - lib/norikra/engine.rb
+- lib/norikra/error.rb
 - lib/norikra/logger.rb
 - lib/norikra/logger_mizuno_patch.rb
 - lib/norikra/output_pool.rb
 - lib/norikra/query.rb
 - lib/norikra/query/ast.rb
 - lib/norikra/rpc.rb
+- lib/norikra/rpc/error.rb
 - lib/norikra/rpc/handler.rb
 - lib/norikra/rpc/http.rb
 - lib/norikra/server.rb