script_core 0.1.1 → 0.2.4

data/ext/enterprise_script_service/mruby/doc/guides/mrbgems.md

@@ -37,11 +37,16 @@ conf.gem :mgem => 'mruby-yaml'
 conf.gem :mgem => 'yaml' # 'mruby-' prefix could be omitted
 ```
 
+For specifying commit hash to checkout use `:checksum_hash` option:
+```ruby
+conf.gem mgem: 'mruby-redis', checksum_hash: '3446d19fc4a3f9697b5ddbf2a904f301c42f2f4e'
+```
+
 If there is missing dependencies, mrbgem dependencies solver will reference
 mrbgem from core or mgem-list.
 
-To pull all gems from remote GIT repository on build, call ```./minirake -p```,
-or ```./minirake --pull-gems```.
+To pull all gems from remote GIT repository on build, call ```rake -p```,
+or ```rake --pull-gems```.
 
 NOTE: `:bitbucket` option supports only git. Hg is unsupported in this version.
 
@@ -230,7 +235,7 @@ So it is recommended not to put GEM's local header files on include/.
 These exports are retroactive.
 For example: when B depends to C and A depends to B, A will get include paths exported by C.
 
-Exported include_paths are automatically appended to GEM local include_paths by Minirake.
+Exported include_paths are automatically appended to GEM local include_paths by rake.
 You can use `spec.export_include_paths` accessor if you want more complex build.
 
 

data/ext/enterprise_script_service/mruby/doc/limitations.md

@@ -14,17 +14,17 @@ This document does not contain a complete list of limitations.
 Please help to improve it by submitting your findings.
 
 
-## ```1/2``` gives ```0.5```
+## `1/2` gives `0.5`
 
-Since mruby does not have ```Bignum```, bigger integers are represented
-by ```Float``` numbers. To enhance interoperability between ```Fixnum```
-and ```Float```, mruby provides ```Float#upto``` and other iterating
-methods for the ```Float``` class.  As a side effect, ```1/2``` gives ```0.5```
-not ```0```.
+Since mruby does not have `Bignum`, bigger integers are represented
+by `Float` numbers. To enhance interoperability between `Fixnum`
+and `Float`, mruby provides `Float#upto` and other iterating
+methods for the `Float` class.  As a side effect, `1/2` gives `0.5`
+not `0`.
 
-## ```Array``` passed to ```puts```
+## `Array` passed to `puts`
 
-Passing an Array to ```puts``` results in different output.
+Passing an Array to `puts` results in different output.
 
 ```ruby
 puts [1,2,3]
@@ -38,15 +38,15 @@ puts [1,2,3]
 3
 ```
 
-#### mruby [2.0.1 (2019-4-4)]
+#### mruby [2.1.0 (2019-11-19)]
 
 ```
 [1, 2, 3]
 ```
 
-## ```Kernel.raise``` in rescue clause
+## `Kernel.raise` in rescue clause
 
-```Kernel.raise``` without arguments does not raise the current exception within
+`Kernel.raise` without arguments does not raise the current exception within
 a rescue clause.
 
 ```ruby
@@ -59,21 +59,21 @@ end
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-```ZeroDivisionError``` is raised.
+`ZeroDivisionError` is raised.
 
-#### mruby [2.0.1 (2019-4-4)]
+#### mruby [2.1.0 (2019-11-19)]
 
 No exception is raised.
 
 ## Fiber execution can't cross C function boundary
 
-mruby's ```Fiber``` is implemented in a similar way to Lua's co-routine. This
+mruby's `Fiber` is implemented in a similar way to Lua's co-routine. This
 results in the consequence that you can't switch context within C functions.
-Only exception is ```mrb_fiber_yield``` at return.
+Only exception is `mrb_fiber_yield` at return.
 
-## ```Array``` does not support instance variables
+## `Array` does not support instance variables
 
-To reduce memory consumption ```Array``` does not support instance variables.
+To reduce memory consumption `Array` does not support instance variables.
 
 ```ruby
 class Liste < Array
@@ -87,16 +87,16 @@ p Liste.new "foobar"
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-``` [] ```
+` [] `
 
-#### mruby [2.0.1 (2019-4-4)]
+#### mruby [2.1.0 (2019-11-19)]
 
-```ArgumentError``` is raised.
+`ArgumentError` is raised.
 
 ## Method visibility
 
 For simplicity reasons no method visibility (public/private/protected) is
-supported.
+supported. Those methods are defined but they are dummy methods.
 
 ```ruby
 class VisibleTest
@@ -119,17 +119,53 @@ false
 true
 ```
 
-#### mruby [2.0.1 (2019-4-4)]
+#### mruby [2.1.0 (2019-11-19)]
 
 ```
 true
 true
 ```
 
-## defined?
+### Visibility Declaration
 
-The ```defined?``` keyword is considered too complex to be fully
-implemented. It is recommended to use ```const_defined?``` and
+The declaration form of following visibility methods are not implemented.
+
+* `public`
+* `private`
+* `protected`
+* `module_function`
+
+Especially, `module_function` method is not dummy, but no declaration form.
+
+```
+module TestModule
+  module_function
+  def test_func
+    p 'test_func called'
+  end
+
+  test_func
+end
+
+p 'ok'
+```
+
+#### Ruby [ruby 2.5.5p157 (2019-03-15 revision 67260)]
+
+```
+ok
+```
+
+#### mruby [2.1.0 (2019-11-19)]
+
+```
+test.rb:8: undefined method 'test_func' (NoMethodError)
+```
+
+## `defined?`
+
+The `defined?` keyword is considered too complex to be fully
+implemented. It is recommended to use `const_defined?` and
 other reflection methods instead.
 
 ```ruby
@@ -142,11 +178,11 @@ defined?(Foo)
 nil
 ```
 
-#### mruby [2.0.1 (2019-4-4)]
+#### mruby [2.1.0 (2019-11-19)]
 
-```NameError``` is raised.
+`NameError` is raised.
 
-## ```alias``` on global variables
+## `alias` on global variables
 
 Aliasing a global variable works in CRuby but is not part
 of the ISO standard.
@@ -157,9 +193,9 @@ alias $a $__a__
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-``` nil ```
+` nil `
 
-#### mruby [2.0.1 (2019-4-4)]
+#### mruby [2.1.0 (2019-11-19)]
 
 Syntax error
 
@@ -178,15 +214,15 @@ end
 
 #### Ruby [ruby 2.0.0p645 (2015-04-13 revision 50299)]
 
-```ArgumentError``` is raised.
-The re-defined ```+``` operator does not accept any arguments.
+`ArgumentError` is raised.
+The re-defined `+` operator does not accept any arguments.
 
-#### mruby [2.0.1 (2019-4-4)]
+#### mruby [2.1.0 (2019-11-19)]
 
-``` 'ab' ```
+` 'ab' `
 Behavior of the operator wasn't changed.
 
-## Kernel#binding is not supported
+## `Kernel#binding` is not supported
 
 `Kernel#binding` method is not supported.
 
@@ -197,7 +233,7 @@ $ ruby -e 'puts Proc.new {}.binding'
 #<Binding:0x00000e9deabb9950>
 ```
 
-#### mruby [2.0.1 (2019-4-4)]
+#### mruby [2.1.0 (2019-11-19)]
 
 ```
 $ ./bin/mruby -e 'puts Proc.new {}.binding'
@@ -219,7 +255,7 @@ $ ruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
 [[{"a"=>1}], {:b=>2}]
 ```
 
-#### mruby [mruby 2.0.1]
+#### mruby [mruby 2.1.0]
 
 ```
 $ ./bin/mruby -e 'def m(*r,**k) p [r,k] end; m("a"=>1,:b=>2)'
@@ -238,7 +274,7 @@ Destructured arguments (`b` and `c` in above example) cannot be accessed
 from the default expression of optional arguments and keyword arguments,
 since actual assignment is done after the evaluation of those default
 expressions. Thus:
-    
+
 ```ruby
 def f(a,(b,c),d=b)
   p [a,b,c,d]
@@ -247,3 +283,17 @@ f(1,[2,3])
 ```
 
 CRuby gives `[1,2,3,nil]`. mruby raises `NoMethodError` for `b`.
+
+## `nil?` redefinition in conditional expressions
+
+Redefinition of `nil?` is ignored in conditional expressions.
+
+```ruby
+a = "a"
+def a.nil?
+  true
+end
+puts(a.nil? ? "truthy" : "falsy")
+```
+
+Ruby outputs `falsy`. mruby outputs `truthy`.

data/ext/enterprise_script_service/mruby/doc/opcode.md

@@ -31,97 +31,97 @@ with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed.
 
 ## table.1 Instruction Table
 
-|Instruction Name |Operand type |Semantics        
-|-----------------|-------------|-----------------
-|OP_NOP           | -           |                 
-|OP_MOVE"         |BB           |R(a) = R(b)      
-|OP_LOADL"        |BB           |R(a) = Pool(b)   
-|OP_LOADI"        |BsB          |R(a) = mrb_int(b)
-|OP_LOADI_0'      |B            |R(a) = 0
-|OP_LOADI_1'      |B            |R(a) = 1
-|OP_LOADI_2'      |B            |R(a) = 2
-|OP_LOADI_3'      |B            |R(a) = 3
-|OP_LOADSYM"      |BB           |R(a) = Syms(b)
-|OP_LOADNIL'      |B            |R(a) = nil
-|OP_LOADSELF'     |B            |R(a) = self
-|OP_LOADT'        |B            |R(a) = true
-|OP_LOADF'        |B            |R(a) = false
-|OP_GETGV"        |BB           |R(a) = getglobal(Syms(b))
-|OP_SETGV"        |BB           |setglobal(Syms(b), R(a))
-|OP_GETSV"        |BB           |R(a) = Special[b]
-|OP_SETSV"        |BB           |Special[b] = R(a)
-|OP_GETIV"        |BB           |R(a) = ivget(Syms(b))
-|OP_SETIV"        |BB           |ivset(Syms(b),R(a))
-|OP_GETCV"        |BB           |R(a) = cvget(Syms(b))
-|OP_SETCV"        |BB           |cvset(Syms(b),R(a))
-|OP_GETCONST"     |BB           |R(a) = constget(Syms(b))
-|OP_SETCONST"     |BB           |constset(Syms(b),R(a))
-|OP_GETMCNST"     |BB           |R(a) = R(a)::Syms(b)
-|OP_SETMCNST"     |BB           |R(a+1)::Syms(b) = R(a)
-|OP_GETUPVAR'     |BBB          |R(a) = uvget(b,c)
-|OP_SETUPVAR'     |BBB          |uvset(b,c,R(a))
-|OP_JMP           |S            |pc+=a
-|OP_JMPIF'        |SB           |if R(b) pc+=a
-|OP_JMPNOT'       |SB           |if !R(b) pc+=a
-|OP_ONERR         |sS           |rescue_push(pc+a)
-|OP_EXCEPT'       |B            |R(a) = exc
-|OP_RESCUE"       |BB           |R(b) = R(a).isa?(R(b))
-|OP_POPERR        |B            |a.times{rescue_pop()}
-|OP_RAISE'        |B            |raise(R(a))
-|OP_EPUSH'        |B            |ensure_push(SEQ[a])
-|OP_EPOP          |B            |A.times{ensure_pop().call}
-|OP_SENDV"        |BB           |R(a) = call(R(a),Syms(b),*R(a+1))
-|OP_SENDVB"       |BB           |R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))
-|OP_SEND"         |BBB          |R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))
-|OP_SENDB"        |BBB          |R(a) = call(R(a),Syms(Bx),R(a+1),...,R(a+c),&R(a+c+1))
-|OP_CALL'         |B            |R(a) = self.call(frame.argc, frame.argv)
-|OP_SUPER'        |BB           |R(a) = super(R(a+1),... ,R(a+b+1))
-|OP_ARGARY'       |BS           |R(a) = argument array (16=5:1:5:1:4)
-|OP_ENTER         |W            |arg setup according to flags (23=5:5:1:5:5:1:1)
-|OP_KARG"         |BB           |R(a) = kdict[Syms(Bx)]                          # todo
-|OP_KARG2"        |BB           |R(a) = kdict[Syms(Bx)]; kdict.rm(Syms(b))       # todo
-|OP_RETURN'       |B            |return R(a) (normal)
-|OP_RETURN_BLK'   |B            |return R(a) (in-block return)
-|OP_BREAK'        |B            |break R(a)
-|OP_BLKPUSH'      |BS           |R(a) = block (16=5:1:5:1:4)
-|OP_ADD"          |BB           |R(a) = R(a)+R(a+1)
-|OP_ADDI"         |BBB          |R(a) = R(a)+mrb_int(c)
-|OP_SUB"          |BB           |R(a) = R(a)-R(a+1)
-|OP_SUBI"         |BB           |R(a) = R(a)-C
-|OP_MUL"          |BB           |R(a) = R(a)*R(a+1)
-|OP_DIV"          |BB           |R(a) = R(a)/R(a+1)
-|OP_EQ"           |BB           |R(a) = R(a)==R(a+1)
-|OP_LT"           |BB           |R(a) = R(a)<R(a+1)
-|OP_LE"           |BB           |R(a) = R(a)<=R(a+1)
-|OP_GT"           |BB           |R(a) = R(a)>R(a+1)
-|OP_GE"           |BB           |R(a) = R(a)>=R(a+1)
-|OP_ARRAY'        |BB           |R(a) = ary_new(R(a),R(a+1)..R(a+b))
-|OP_ARRAY2"       |BB           |R(a) = ary_new(R(b),R(b+1)..R(b+c))
-|OP_ARYCAT'       |B            |ary_cat(R(a),R(a+1))
-|OP_ARYPUSH'      |B            |ary_push(R(a),R(a+1))
-|OP_AREF'         |BB           |R(a) = R(a)[b]
-|OP_ASET'         |BB           |R(a)[b] = R(a+1)
-|OP_APOST'        |BB           |*R(a),R(A+1)..R(A+C) = R(a)[B..]
-|OP_STRING"       |BB           |R(a) = str_dup(Lit(b))
-|OP_STRCAT'       |B            |str_cat(R(a),R(a+1))
-|OP_HASH'         |BB           |R(a) = hash_new(R(a),R(a+1)..R(a+b))
-|OP_HASHADD'      |BB           |R(a) = hash_push(R(a),R(a+1)..R(a+b))
-|OP_LAMBDA"       |BB           |R(a) = lambda(SEQ[b],OP_L_LAMBDA)
-|OP_BLOCK"        |BB           |R(a) = lambda(SEQ[b],OP_L_BLOCK)
-|OP_METHOD"       |BB           |R(a) = lambda(SEQ[b],OP_L_METHOD)
-|OP_RANGE_INC'    |B            |R(a) = range_new(R(a),R(a+1),FALSE)
-|OP_RANGE_EXC'    |B            |R(a) = range_new(R(a),R(a+1),TRUE)
-|OP_OCLASS'       |B            |R(a) = ::Object
-|OP_CLASS"        |BB           |R(a) = newclass(R(a),Syms(b),R(a+1))
-|OP_MODULE"       |BB           |R(a) = newmodule(R(a),Syms(b))
-|OP_EXEC"         |BB           |R(a) = blockexec(R(a),SEQ[b])
-|OP_DEF"          |BB           |R(a).newmethod(Syms(b),R(a+1))
-|OP_ALIAS'        |B            |alias_method(R(a),R(a+1),R(a+2))
-|OP_UNDEF"        |BB           |undef_method(R(a),Syms(b))
-|OP_SCLASS'       |B            |R(a) = R(a).singleton_class
-|OP_TCLASS'       |B            |R(a) = target_class
-|OP_ERR'          |B            |raise(RuntimeError, Lit(Bx))
-|OP_EXT1          |-            |make 1st operand 16bit
-|OP_EXT2          |-            |make 2nd operand 16bit
-|OP_EXT3          |-            |make 1st and 2nd operands 16bit
-|OP_STOP          |-            |stop VM
+| Instruction Name | Operand type | Semantics        	|
+|:-----------------|--------------|---------------------|
+| OP_NOP           | -            |                  	|
+| OP_MOVE"         | BB           | R(a) = R(b)      	
+| OP_LOADL"        | BB           | R(a) = Pool(b)   	
+| OP_LOADI"        | BsB          | R(a) = mrb_int(b)	
+| OP_LOADI_0'      | B            | R(a) = 0	
+| OP_LOADI_1'      | B            | R(a) = 1	
+| OP_LOADI_2'      | B            | R(a) = 2	
+| OP_LOADI_3'      | B            | R(a) = 3	
+| OP_LOADSYM"      | BB           | R(a) = Syms(b)	
+| OP_LOADNIL'      | B            | R(a) = nil	
+| OP_LOADSELF'     | B            | R(a) = self	
+| OP_LOADT'        | B            | R(a) = true	
+| OP_LOADF'        | B            | R(a) = false	
+| OP_GETGV"        | BB           | R(a) = getglobal(Syms(b))	
+| OP_SETGV"        | BB           | setglobal(Syms(b), R(a))	
+| OP_GETSV"        | BB           | R(a) = Special[b]	
+| OP_SETSV"        | BB           | Special[b] = R(a)	
+| OP_GETIV"        | BB           | R(a) = ivget(Syms(b))	
+| OP_SETIV"        | BB           | ivset(Syms(b),R(a))	
+| OP_GETCV"        | BB           | R(a) = cvget(Syms(b))	
+| OP_SETCV"        | BB           | cvset(Syms(b),R(a))	
+| OP_GETCONST"     | BB           | R(a) = constget(Syms(b))	
+| OP_SETCONST"     | BB           | constset(Syms(b),R(a))	
+| OP_GETMCNST"     | BB           | R(a) = R(a)::Syms(b)	
+| OP_SETMCNST"     | BB           | R(a+1)::Syms(b) = R(a)	
+| OP_GETUPVAR'     | BBB          | R(a) = uvget(b,c)	
+| OP_SETUPVAR'     | BBB          | uvset(b,c,R(a))	
+| OP_JMP           | S            | pc+=a	
+| OP_JMPIF'        | SB           | if R(b) pc+=a	
+| OP_JMPNOT'       | SB           | if !R(b) pc+=a	
+| OP_ONERR         | sS           | rescue_push(pc+a)	
+| OP_EXCEPT'       | B            | R(a) = exc	
+| OP_RESCUE"       | BB           | R(b) = R(a).isa?(R(b))	
+| OP_POPERR        | B            | a.times{rescue_pop()}	
+| OP_RAISE'        | B            | raise(R(a))	
+| OP_EPUSH'        | B            | ensure_push(SEQ[a])	
+| OP_EPOP          | B            | A.times{ensure_pop().call}	
+| OP_SENDV"        | BB           | R(a) = call(R(a),Syms(b),*R(a+1))	
+| OP_SENDVB"       | BB           | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))	
+| OP_SEND"         | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))	
+| OP_SENDB"        | BBB          | R(a) = call(R(a),Syms(Bx),R(a+1),...,R(a+c),&R(a+c+1))	
+| OP_CALL'         | B            | R(a) = self.call(frame.argc, frame.argv)	
+| OP_SUPER'        | BB           | R(a) = super(R(a+1),... ,R(a+b+1))	
+| OP_ARGARY'       | BS           | R(a) = argument array (16=5:1:5:1:4)	
+| OP_ENTER         | W            | arg setup according to flags (23=5:5:1:5:5:1:1)	
+| OP_KARG"         | BB           | R(a) = kdict[Syms(Bx)]                          # todo	
+| OP_KARG2"        | BB           | R(a) = kdict[Syms(Bx)]; kdict.rm(Syms(b))       # todo	
+| OP_RETURN'       | B            | return R(a) (normal)	
+| OP_RETURN_BLK'   | B            | return R(a) (in-block return)	
+| OP_BREAK'        | B            | break R(a)	
+| OP_BLKPUSH'      | BS           | R(a) = block (16=5:1:5:1:4)	
+| OP_ADD"          | BB           | R(a) = R(a)+R(a+1)	
+| OP_ADDI"         | BBB          | R(a) = R(a)+mrb_int(c)	
+| OP_SUB"          | BB           | R(a) = R(a)-R(a+1)	
+| OP_SUBI"         | BB           | R(a) = R(a)-C	
+| OP_MUL"          | BB           | R(a) = R(a)*R(a+1)	
+| OP_DIV"          | BB           | R(a) = R(a)/R(a+1)	
+| OP_EQ"           | BB           | R(a) = R(a)==R(a+1)	
+| OP_LT"           | BB           | R(a) = R(a)<R(a+1)	
+| OP_LE"           | BB           | R(a) = R(a)<=R(a+1)	
+| OP_GT"           | BB           | R(a) = R(a)>R(a+1)	
+| OP_GE"           | BB           | R(a) = R(a)>=R(a+1)	
+| OP_ARRAY'        | BB           | R(a) = ary_new(R(a),R(a+1)..R(a+b))	
+| OP_ARRAY2"       | BB           | R(a) = ary_new(R(b),R(b+1)..R(b+c))	
+| OP_ARYCAT'       | B            | ary_cat(R(a),R(a+1))	
+| OP_ARYPUSH'      | B            | ary_push(R(a),R(a+1))	
+| OP_AREF'         | BB           | R(a) = R(a)[b]	
+| OP_ASET'         | BB           | R(a)[b] = R(a+1)	
+| OP_APOST'        | BB           | *R(a),R(A+1)..R(A+C) = R(a)[B..]	
+| OP_STRING"       | BB           | R(a) = str_dup(Lit(b))	
+| OP_STRCAT'       | B            | str_cat(R(a),R(a+1))	
+| OP_HASH'         | BB           | R(a) = hash_new(R(a),R(a+1)..R(a+b))	
+| OP_HASHADD'      | BB           | R(a) = hash_push(R(a),R(a+1)..R(a+b))	
+| OP_LAMBDA"       | BB           | R(a) = lambda(SEQ[b],OP_L_LAMBDA)	
+| OP_BLOCK"        | BB           | R(a) = lambda(SEQ[b],OP_L_BLOCK)	
+| OP_METHOD"       | BB           | R(a) = lambda(SEQ[b],OP_L_METHOD)	
+| OP_RANGE_INC'    | B            | R(a) = range_new(R(a),R(a+1),FALSE)	
+| OP_RANGE_EXC'    | B            | R(a) = range_new(R(a),R(a+1),TRUE)	
+| OP_OCLASS'       | B            | R(a) = ::Object	
+| OP_CLASS"        | BB           | R(a) = newclass(R(a),Syms(b),R(a+1))	
+| OP_MODULE"       | BB           | R(a) = newmodule(R(a),Syms(b))	
+| OP_EXEC"         | BB           | R(a) = blockexec(R(a),SEQ[b])	
+| OP_DEF"          | BB           | R(a).newmethod(Syms(b),R(a+1))	
+| OP_ALIAS'        | B            | alias_method(R(a),R(a+1),R(a+2))	
+| OP_UNDEF"        | BB           | undef_method(R(a),Syms(b))	
+| OP_SCLASS'       | B            | R(a) = R(a).singleton_class	
+| OP_TCLASS'       | B            | R(a) = target_class	
+| OP_ERR'          | B            | raise(RuntimeError, Lit(Bx))	
+| OP_EXT1          | -            | make 1st operand 16bit	
+| OP_EXT2          | -            | make 2nd operand 16bit	
+| OP_EXT3          | -            | make 1st and 2nd operands 16bit	
+| OP_STOP          | -            | stop VM