norikra 1.1.2-java → 1.2.0-java

data/spec/listener_spec.rb

@@ -4,6 +4,19 @@ require_relative './spec_helper'
 require 'json'
 require 'norikra/listener'
 
+class DummyEngine
+  attr_reader :events
+
+  def initialize
+    @events = {}
+  end
+
+  def send(target, events)
+    @events[target] ||= []
+    @events[target].push(*events)
+  end
+end
+
 class DummyOutputPool
   attr_reader :pool
 
@@ -18,17 +31,15 @@ class DummyOutputPool
   end
 end
 
-describe Norikra::Listener do
+describe Norikra::Listener::Base do
   it 'should be initialized' do
-    dummy_pool = DummyOutputPool.new
     statistics = {output: 0}
-    expect { Norikra::Listener.new('name', 'group', dummy_pool, statistics) }.not_to raise_error
+    expect { Norikra::Listener::Base.new('name', 'group', statistics) }.not_to raise_error
   end
 
   describe '#type_convert' do
-    dummy_pool = DummyOutputPool.new
     statistics = {output: 0}
-    listener = Norikra::Listener.new('name', 'group', dummy_pool, statistics)
+    listener = Norikra::Listener::Base.new('name', 'group', statistics)
 
     it 'returns value itself for number, boolean and nil' do
       val = 10001
@@ -104,10 +115,24 @@ describe Norikra::Listener do
     end
   end
 
+  ### TODO: add specs of #start, #process_async, #push and default #update
+  ### TODO: add norikra/listener_spec_helper.rb
+end
+
+describe Norikra::Listener::MemoryPool do
+  describe '.check' do
+    it 'always returns true' do
+      expect(Norikra::Listener::MemoryPool.check(nil)).to be_truthy
+      expect(Norikra::Listener::MemoryPool.check('')).to be_truthy
+      expect(Norikra::Listener::MemoryPool.check('FOO')).to be_truthy
+      expect(Norikra::Listener::MemoryPool.check('FOO()')).to be_truthy
+    end
+  end
+
   describe '#update' do
-    dummy_pool = DummyOutputPool.new
     statistics = {output: 0}
-    listener = Norikra::Listener.new('name', 'group', dummy_pool, statistics)
+    listener = Norikra::Listener::MemoryPool.new('name', 'group', statistics)
+    listener.output_pool = dummy_pool = DummyOutputPool.new
 
     it 'pushs events into pool, with current time' do
       listener.update([{"n1" => 100, "s" => "string one"}, {"n1" => 101, "s" => "string two"}], [])
@@ -124,30 +149,35 @@ describe Norikra::Listener do
   end
 end
 
-class DummyEngine
-  attr_reader :events
+describe Norikra::Listener::Loopback do
+  describe '.check' do
+    it 'returns nil for nil group' do
+      expect(Norikra::Listener::Loopback.check(nil)).to be_nil
+    end
 
-  def initialize
-    @events = {}
-  end
+    it 'returns nil for string group name without prefix' do
+      expect(Norikra::Listener::Loopback.check('a')).to be_nil
+      expect(Norikra::Listener::Loopback.check('group1')).to be_nil
+      expect(Norikra::Listener::Loopback.check('LOOPBACK')).to be_nil
+    end
 
-  def send(target, events)
-    @events[target] ||= []
-    @events[target].push(*events)
+    it 'returns specified string as loopback target by parentheses' do
+      expect(Norikra::Listener::Loopback.check('LOOPBACK()')).to be_nil
+      expect(Norikra::Listener::Loopback.check('LOOPBACK(a)')).to eql('a')
+      expect(Norikra::Listener::Loopback.check('LOOPBACK(loopback_target)')).to eql('loopback_target')
+      expect(Norikra::Listener::Loopback.check('LOOPBACK(target name)')).to eql('target name') # should be invalid on 'open'
+    end
   end
-end
 
-describe Norikra::LoopbackListener do
   it 'should be initialized' do
-    dummy_engine = DummyEngine.new
     statistics = {output: 0}
-    expect { Norikra::LoopbackListener.new(dummy_engine, 'name', 'LOOPBACK(target1)', statistics) }.not_to raise_error
+    expect { Norikra::Listener::Loopback.new('name', 'LOOPBACK(target1)', statistics) }.not_to raise_error
   end
 
   describe '#update' do
-    dummy_engine = DummyEngine.new
     statistics = {output: 0}
-    listener = Norikra::LoopbackListener.new(dummy_engine, 'name', 'LOOPBACK(target1)', statistics)
+    listener = Norikra::Listener::Loopback.new('name', 'LOOPBACK(target1)', statistics)
+    listener.engine = dummy_engine = DummyEngine.new
 
     it 'sends events into engine with target name' do
       listener.update([{"n1" => 100, "s" => "string one"}, {"n1" => 101, "s" => "string two"}], [])
@@ -163,17 +193,25 @@ describe Norikra::LoopbackListener do
   end
 end
 
-describe Norikra::StdoutListener do
+describe Norikra::Listener::Stdout do
+  describe '.check' do
+    it 'returns true if group name is "STDOUT()"' do
+      expect(Norikra::Listener::Stdout.check(nil)).to be_falsy
+      expect(Norikra::Listener::Stdout.check("")).to be_falsy
+      expect(Norikra::Listener::Stdout.check("foo")).to be_falsy
+      expect(Norikra::Listener::Stdout.check("STDOUT")).to be_falsy
+      expect(Norikra::Listener::Stdout.check("STDOUT()")).to be_truthy
+    end
+  end
+
   it 'should be initialized' do
-    dummy_engine = DummyEngine.new
     statistics = {output: 0}
-    expect { Norikra::StdoutListener.new(dummy_engine, 'name', 'STDOUT()', statistics) }.not_to raise_error
+    expect { Norikra::Listener::Stdout.new('name', 'STDOUT()', statistics) }.not_to raise_error
   end
 
   describe '#update' do
-    dummy_engine = DummyEngine.new
     statistics = {output: 0}
-    listener = Norikra::StdoutListener.new(dummy_engine, 'name', 'STDOUT()', statistics)
+    listener = Norikra::Listener::Stdout.new('name', 'STDOUT()', statistics)
     dummyio = StringIO.new
     listener.instance_eval{ @stdout = dummyio }
 

data/spec/query_spec.rb

@@ -89,6 +89,73 @@ describe Norikra::Query do
           expect(q.fields('TestTable')).to eql([])
           expect(q.fields(nil)).to eql([])
 
+          expect(q.nullable_fields).to eql([])
+          expect(q.nullable_fields('TestTable')).to eql([])
+          expect(q.nullable_fields(nil)).to eql([])
+
+          expect(q.invalid?).to be_falsy
+        end
+
+        it 'returns query instances collectly parsed, even if it has property' do
+          expression = 'SELECT rate(a.b) FROM TestTable output snapshot every 2 sec'
+          q = Norikra::Query.new(
+            :name => 'TestTable query1', :expression => expression
+          )
+          expect(q.name).to eql('TestTable query1')
+          expect(q.group).to be_nil
+          expect(q.expression).to eql(expression)
+          expect(q.targets).to eql(['TestTable'])
+
+          expect(q.fields).to eql(['a.b'])
+          expect(q.fields('TestTable')).to eql(['a.b'])
+          expect(q.fields(nil)).to eql([])
+
+          expect(q.nullable_fields).to eql([])
+          expect(q.nullable_fields('TestTable')).to eql([])
+          expect(q.nullable_fields(nil)).to eql([])
+
+          expect(q.invalid?).to be_falsy
+        end
+
+        it 'returns query instances collectly parsed, with built-in NULLABLE()' do
+          expression = 'SELECT a, b, NULLABLE(c) FROM TestTable output snapshot every 2 sec'
+          q = Norikra::Query.new(
+            :name => 'TestTable query1', :expression => expression
+          )
+          expect(q.name).to eql('TestTable query1')
+          expect(q.group).to be_nil
+          expect(q.expression).to eql(expression)
+          expect(q.targets).to eql(['TestTable'])
+
+          expect(q.fields).to eql(['a', 'b', 'c'])
+          expect(q.fields('TestTable')).to eql(['a', 'b', 'c'])
+          expect(q.fields(nil)).to eql([])
+
+          expect(q.nullable_fields).to eql(['c'])
+          expect(q.nullable_fields('TestTable')).to eql(['c'])
+          expect(q.nullable_fields(nil)).to eql([])
+
+          expect(q.invalid?).to be_falsy
+        end
+
+        it 'returns query instances collectly parsed, with built-in NULLABLE(), case-insensitive' do
+          expression = 'SELECT a, b, nullable(c) FROM TestTable output snapshot every 2 sec'
+          q = Norikra::Query.new(
+            :name => 'TestTable query1', :expression => expression
+          )
+          expect(q.name).to eql('TestTable query1')
+          expect(q.group).to be_nil
+          expect(q.expression).to eql(expression)
+          expect(q.targets).to eql(['TestTable'])
+
+          expect(q.fields).to eql(['a', 'b', 'c'])
+          expect(q.fields('TestTable')).to eql(['a', 'b', 'c'])
+          expect(q.fields(nil)).to eql([])
+
+          expect(q.nullable_fields).to eql(['c'])
+          expect(q.nullable_fields('TestTable')).to eql(['c'])
+          expect(q.nullable_fields(nil)).to eql([])
+
           expect(q.invalid?).to be_falsy
         end
       end
@@ -178,9 +245,9 @@ describe Norikra::Query do
           expect(q.targets).to eql(['RfidEvent', 'Zones'])
 
           expect(q.fields).to eql(['name','zoneName','zoneId'].sort)
+          expect(q.fields(nil)).to eql([])
           expect(q.fields('RfidEvent')).to eql(['zoneId'])
           expect(q.fields('Zones')).to eql(['name','zoneName','zoneId'].sort)
-          expect(q.fields(nil)).to eql([])
 
           expect(q.invalid?).to be_falsy
         end
@@ -203,6 +270,28 @@ describe Norikra::Query do
 
           expect(q.invalid?).to be_falsy
         end
+
+        it 'returns query instances collectly parsed, even if it has nullable field' do
+          expression = 'select zoneId, (select NULLABLE(name) from Zones.std:unique(zoneName) where zoneId = RfidEvent.zoneId) as name from RfidEvent'
+          q = Norikra::Query.new(
+            :name => 'TestTable query5', :expression => expression
+          )
+          expect(q.name).to eql('TestTable query5')
+          expect(q.expression).to eql(expression)
+          expect(q.targets).to eql(['RfidEvent', 'Zones'].sort)
+
+          expect(q.fields).to eql(['name','zoneName','zoneId'].sort)
+          expect(q.fields('RfidEvent')).to eql(['zoneId'])
+          expect(q.fields('Zones')).to eql(['name','zoneName','zoneId'].sort)
+          expect(q.fields(nil)).to eql([])
+
+          expect(q.nullable_fields).to eql(['name'])
+          expect(q.nullable_fields(nil)).to eql([])
+          expect(q.nullable_fields('RfidEvent')).to eql([])
+          expect(q.nullable_fields('Zones')).to eql(['name'])
+
+          expect(q.invalid?).to be_falsy
+        end
       end
 
       context 'with query with subquery (from clause)' do
@@ -308,6 +397,25 @@ describe Norikra::Query do
         end
       end
 
+      context 'with non-builtin functions (ex: udf) with property arguments' do
+        it 'returns property fields correctly' do
+          expression = "select name, FOO(value) from EventA"
+          q = Norikra::Query.new(
+            :name => 'TestTable query10', :expression => expression
+          )
+          expect(q.name).to eql('TestTable query10')
+          expect(q.group).to be_nil
+          expect(q.expression).to eql(expression)
+          expect(q.targets).to eql(['EventA'])
+          expect(q.aliases).to eql([])
+          expect(q.fields).to eql(['name', 'value'].sort)
+          expect(q.fields('EventA')).to eql(['name', 'value'].sort)
+          expect(q.fields(nil)).to eql([])
+
+          expect(q.invalid?).to be_falsy
+        end
+      end
+
       context 'with "*" selection list' do
         it 'returns query instance which is singed as invalid for norikra query' do
           expression = "select * from target1 where key1=1"
@@ -317,34 +425,30 @@ describe Norikra::Query do
           expect(q.invalid?).to be_truthy
         end
       end
-    end
 
-    describe '.looback' do
-      it 'returns nil for nil group' do
-        expect(Norikra::Query.loopback(nil)).to be_nil
-      end
+      context 'with valid/invalid NULLABLE(...)' do
+        it 'returns query instance to show valid/invalid' do
+          exp0 = "SELECT a, NULLABLE( ) FROM t1 where a > 1"
+          expect(Norikra::Query.new(name:'q0', expression: exp0).invalid?).to be_truthy
 
-      it 'returns nil for string group name without prefix' do
-        expect(Norikra::Query.loopback('a')).to be_nil
-        expect(Norikra::Query.loopback('group1')).to be_nil
-        expect(Norikra::Query.loopback('LOOPBACK')).to be_nil
-      end
+          exp1 = "SELECT a, NULLABLE( b ) FROM t1 where a > 1"
+          expect(Norikra::Query.new(name:'q1', expression: exp1).invalid?).to be_falsy
 
-      it 'returns specified string as loopback target by parentheses' do
-        expect(Norikra::Query.loopback('LOOPBACK()')).to be_nil
-        expect(Norikra::Query.loopback('LOOPBACK(a)')).to eql('a')
-        expect(Norikra::Query.loopback('LOOPBACK(loopback_target)')).to eql('loopback_target')
-        expect(Norikra::Query.loopback('LOOPBACK(target name)')).to eql('target name') # should be invalid on 'open'
-      end
-    end
+          exp2 = "SELECT a, NULLABLE( b ) FROM t1 where a || b"
+          expect(Norikra::Query.new(name:'q2', expression: exp2).invalid?).to be_falsy
+
+          exp3 = "SELECT a, NULLABLE( a, b ) FROM t1 where a"
+          expect(Norikra::Query.new(name:'q3', expression: exp3).invalid?).to be_truthy
 
-    describe '.stdout?' do
-      it 'returns true if group name is "STDOUT()"' do
-        expect(Norikra::Query.stdout?(nil)).to be_falsy
-        expect(Norikra::Query.stdout?("")).to be_falsy
-        expect(Norikra::Query.stdout?("foo")).to be_falsy
-        expect(Norikra::Query.stdout?("STDOUT")).to be_falsy
-        expect(Norikra::Query.stdout?("STDOUT()")).to be_truthy
+          exp4 = "SELECT a, NULLABLE( a + b ) FROM t1 where c"
+          expect(Norikra::Query.new(name:'q4', expression: exp4).invalid?).to be_truthy
+
+          exp5 = "SELECT a, NULLABLE( foo(b) ) FROM t1 where c"
+          expect(Norikra::Query.new(name:'q5', expression: exp5).invalid?).to be_truthy
+
+          exp6 = "SELECT a, NULLABLE( NULLABLE(b) ) FROM t1 where c"
+          expect(Norikra::Query.new(name:'q6', expression: exp6).invalid?).to be_truthy
+        end
       end
     end
 
@@ -380,6 +484,41 @@ describe Norikra::Query do
       end
     end
 
+    describe '.rewrite_nullable_fields' do
+      context 'with NULLABLE()' do
+        expression = 'select a, nullable(b) from TestTable.win:time_batch(10 seconds) where c>0'
+        expected   = 'select a, b from TestTable.win:time_batch(10 seconds) where c>0'
+        it 'returns query without NULLABLE()' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'TestTable' => 'T1'}).toEPL).to eql(expression)
+          end
+        end
+      end
+
+      context 'with NULLABLE() in count(distinct)' do
+        expression = 'select a, count(distinct nullable(b)) from TestTable.win:time_batch(10 seconds) where c>0 group by a'
+        expected   = 'select a, count(distinct b) from TestTable.win:time_batch(10 seconds) where c>0 group by a'
+        it 'returns query without NULLABLE()' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'TestTable' => 'T1'}).toEPL).to eql(expression)
+          end
+        end
+      end
+
+      context 'with some NULLABLE()' do
+        expression = 'select a, NULLABLE(b), NULLABLE(c), count(*) as cnt from TestTable.win:time_batch(10 seconds) where c>0 group by a, b, c'
+        expected   = 'select a, b, c, count(*) AS cnt from TestTable.win:time_batch(10 seconds) where c>0 group by a, b, c'
+        it 'returns query without NULLABLE()' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'TestTable' => 'T1'}).toEPL).to eql(expression)
+          end
+        end
+      end
+    end
+
     describe '.rewrite_event_field_name' do
       context 'without any container field access' do
         expression = 'select count(*) as cnt from TestTable.win:time_batch(10 seconds) where path="/" and size>100 and (param.length())>0'
@@ -566,6 +705,13 @@ describe Norikra::Query do
           model = administrator.compileEPL(e5)
           mapping = {'RfidEvent' => 'R1', 'Zones' => 'Z1'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x5)
+
+          # Fully-qualified field access w/ container field access and NULLABLE()
+          e6 = 'select NULLABLE(RfidEvent.zoneId.$0), (select NULLABLE(name.x) from Zones.std:unique(zoneName) where zoneId=RfidEvent.zoneId.$0) as name from RfidEvent'
+          x6 = 'select R1.zoneId$$0, (select name$x from Z1.std:unique(zoneName) where zoneId=R1.zoneId$$0) as name from R1'
+          model = administrator.compileEPL(e6)
+          mapping = {'RfidEvent' => 'R1', 'Zones' => 'Z1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x6)
         end
       end
 

data/spec/spec_helper.rb

@@ -1,50 +1,4 @@
 require 'rubygems'
-require 'spork'
-#uncomment the following line to use spork with the debugger
-#require 'spork/ext/ruby-debug'
-
-Spork.prefork do
-  # Loading more in this block will cause your tests to run faster. However,
-  # if you change any configuration or code from libraries loaded here, you'll
-  # need to restart spork for it take effect.
-
-end
-
-Spork.each_run do
-  # This code will be run each time you run your specs.
-  Dir.glob('./lib/norikra/**/*.rb').each do |file|
-    load file
-  end
-end
-
-# --- Instructions ---
-# Sort the contents of this file into a Spork.prefork and a Spork.each_run
-# block.
-#
-# The Spork.prefork block is run only once when the spork server is started.
-# You typically want to place most of your (slow) initializer code in here, in
-# particular, require'ing any 3rd-party gems that you don't normally modify
-# during development.
-#
-# The Spork.each_run block is run each time you run your specs.  In case you
-# need to load files that tend to change during development, require them here.
-# With Rails, your application modules are loaded automatically, so sometimes
-# this block can remain empty.
-#
-# Note: You can modify files loaded *from* the Spork.each_run block without
-# restarting the spork server.  However, this file itself will not be reloaded,
-# so if you change any of the code inside the each_run block, you still need to
-# restart the server.  In general, if you have non-trivial code in this file,
-# it's advisable to move it into a separate file so you can easily edit it
-# without restarting spork.  (For example, with RSpec, you could move
-# non-trivial code into a file spec/support/my_helper.rb, making sure that the
-# spec/support/* files are require'd from inside the each_run block.)
-#
-# Any code that is left outside the two blocks will be run during preforking
-# *and* during each_run -- that's probably not what you want.
-#
-# These instructions should self-destruct in 10 seconds.  If they don't, feel
-# free to delete them.
 
 require 'rubygems'
 require 'rspec'

data/spec/typedef_manager_spec.rb

@@ -218,10 +218,16 @@ describe Norikra::TypedefManager do
 
     describe '#generate_query_fieldset' do
       it 'returns fieldset instance with all required(non-optional) fields of target, and fields of query requires' do
-        r = manager.generate_query_fieldset('sample', ['a', 'b','f'], 'qname1', nil)
+        r = manager.generate_query_fieldset('sample', ['a', 'b', 'f'], [], 'qname1', nil)
         expect(r.fields.size).to eql(4) # a,b,c,f
         expect(r.summary).to eql('a:string,b:string,c:float,f:boolean')
       end
+
+      it 'returns fieldset instance with nullable information if specified' do
+        r = manager.generate_query_fieldset('sample', ['a', 'b', 'f'], ['b', 'f'], 'qname1', nil)
+        expect(r.fields.size).to eql(4) # a,b,c,f
+        expect(r.summary).to eql('a:string,b:string:nullable,c:float,f:boolean:nullable')
+      end
     end
 
     describe '#dump_target' do
@@ -233,18 +239,18 @@ describe Norikra::TypedefManager do
 
         r = m.dump_target('sample')
         expect(r).to eql({
-            a: {name: 'a', type: 'string', optional: false},
-            b: {name: 'b', type: 'string', optional: false},
-            c: {name: 'c', type: 'float', optional: false},
-            z: {name: 'z', type: 'boolean', optional: true},
+            a: {name: 'a', type: 'string', optional: false, nullable: false},
+            b: {name: 'b', type: 'string', optional: false, nullable: false},
+            c: {name: 'c', type: 'float', optional: false, nullable: false},
+            z: {name: 'z', type: 'boolean', optional: true, nullable: false},
           })
 
         r = m.dump_target('sample_next')
         expect(r).to eql({
-            a: {name: 'a', type: 'string', optional: false},
-            b: {name: 'b', type: 'string', optional: false},
-            c: {name: 'c', type: 'float', optional: false},
-            d: {name: 'd', type: 'float', optional: false},
+            a: {name: 'a', type: 'string', optional: false, nullable: false},
+            b: {name: 'b', type: 'string', optional: false, nullable: false},
+            c: {name: 'c', type: 'float', optional: false, nullable: false},
+            d: {name: 'd', type: 'float', optional: false, nullable: false},
           })
       end
     end

data/spec/typedef_spec.rb

@@ -290,7 +290,7 @@ describe Norikra::Typedef do
         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(Norikra::ArgumentError)
+        expect { t.replace(:data, set1, set2) }.to raise_error(::ArgumentError)
       end
 
       it 'replaces typedef internal fieldset object for specified field_names_key' do
@@ -540,10 +540,10 @@ describe Norikra::Typedef do
 
         r = t.dump
         expect(r.keys.sort).to eql([:a, :b, :c, :d])
-        expect(r[:a]).to eql({name: 'a', type: 'string', optional: false})
-        expect(r[:b]).to eql({name: 'b', type: 'integer', optional: false})
-        expect(r[:c]).to eql({name: 'c', type: 'float', optional: true})
-        expect(r[:d]).to eql({name: 'd', type: 'string', optional: true})
+        expect(r[:a]).to eql({name: 'a', type: 'string', optional: false, nullable: false})
+        expect(r[:b]).to eql({name: 'b', type: 'integer', optional: false, nullable: false})
+        expect(r[:c]).to eql({name: 'c', type: 'float', optional: true, nullable: false})
+        expect(r[:d]).to eql({name: 'd', type: 'string', optional: true, nullable: false})
 
         t2 = Norikra::Typedef.new(r)
         expect(t2.fields.keys.sort).to eql(fields.keys.sort)
@@ -560,12 +560,12 @@ describe Norikra::Typedef do
 
         r = t.dump
         expect(r.keys.sort).to eql([:a, :b, :c, :d, :e, :f])
-        expect(r[:a]).to eql({name: 'a', type: 'string', optional: false})
-        expect(r[:b]).to eql({name: 'b', type: 'integer', optional: false})
-        expect(r[:c]).to eql({name: 'c', type: 'float', optional: true})
-        expect(r[:d]).to eql({name: 'd', type: 'string', optional: true})
-        expect(r[:e]).to eql({name: 'e', type: 'array', optional: true})
-        expect(r[:f]).to eql({name: 'f', type: 'hash', optional: true})
+        expect(r[:a]).to eql({name: 'a', type: 'string', optional: false, nullable: false})
+        expect(r[:b]).to eql({name: 'b', type: 'integer', optional: false, nullable: false})
+        expect(r[:c]).to eql({name: 'c', type: 'float', optional: true, nullable: false})
+        expect(r[:d]).to eql({name: 'd', type: 'string', optional: true, nullable: false})
+        expect(r[:e]).to eql({name: 'e', type: 'array', optional: true, nullable: false})
+        expect(r[:f]).to eql({name: 'f', type: 'hash', optional: true, nullable: false})
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: norikra
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: java
 authors:
 - TAGOMORI Satoshi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-12-19 00:00:00.000000000 Z
+date: 2015-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mizuno
@@ -164,20 +164,6 @@ dependencies:
         version: '0'
   prerelease: false
   type: :development
-- !ruby/object:Gem::Dependency
-  name: spork
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency
   name: pry
   version_requirements: !ruby/object:Gem::Requirement
@@ -238,11 +224,9 @@ files:
 - lib/norikra/query.rb
 - lib/norikra/query/ast.rb
 - lib/norikra/rpc.rb
-- lib/norikra/rpc/error.rb
 - lib/norikra/rpc/gatekeeper.rb
 - lib/norikra/rpc/handler.rb
 - lib/norikra/rpc/http.rb
-- lib/norikra/rubyudf.rb
 - lib/norikra/server.rb
 - lib/norikra/stats.rb
 - lib/norikra/suspended_query.rb
@@ -272,7 +256,7 @@ files:
 - public/js/bootstrap.min.js
 - public/js/jquery.min.js
 - public/js/norikra.webui.js
-- script/spec_server_pry
+- script/pry
 - spec/engine_spec.rb
 - spec/field_spec.rb
 - spec/fieldset_spec.rb

data/lib/norikra/rubyudf.rb

@@ -1,49 +0,0 @@
-# this is note for future update
-
-# module Norikra
-#   module UDF
-#     class FailedUDFImplementationPureRuby
-#       # require 'jruby/core_ext'
-#       class WootheeIsCrawler < Norikra::UDF::Base # Norikra::UDF::WootheeIsCrawler < Norikra::UDF::Base
-#         def self.init
-#           require 'woothee'
-#         end
-
-#         def self.function_name
-#           "isCrawler"
-#         end
-
-#         def self.isCrawler(agent)
-#           Woothee.is_crawler(agent)
-#         end
-#         class << self
-#           add_method_signature( "isCrawler", [java.lang.Boolean, java.lang.String] )
-#         end
-#       end
-
-#       # for engine.rb
-#       def load_udf_actually(udf_klass)
-#         require 'jruby/core_ext'
-#         udf_klass.init
-
-#         jclass = udf_klass.become_java!(".")
-#         className = jclass.get_name.to_java(:string)
-
-#         #### try for NullPointerException, but doesn't work well
-#         # field = jclass.getDeclaredField("ruby");
-#         # field.setAccessible(java.lang.Boolean::TRUE)
-#         # field.set(nil, org.jruby.Ruby.getGlobalRuntime)
-
-#         functionName = udf_klass.function_name.to_java(:string)
-#         methodName = udf_klass.method_name.to_java(:string)
-
-#         valueCache = udf_klass.value_cache ? VALUE_CACHE_ENUM::ENABLED : VALUE_CACHE_ENUM::DISABLED
-#         filterOptimizable = udf_klass.filter_optimizable ? FILTER_OPTIMIZABLE_ENUM::ENABLED : FILTER_OPTIMIZABLE_ENUM::DISABLED
-#         rethrowExceptions = udf_klass.rethrow_exceptions
-
-#         debug "adding SingleRowFunction", :class => udf_klass.to_s, :javaClass => jclass.get_name
-#         @config.addPlugInSingleRowFunction(functionName, className, methodName, valueCache, filterOptimizable, rethrowExceptions)
-#       end
-#     end
-#   end
-# end