rubex 0.0.1 → 0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3b95dd14dc7e9058f7f9ff1771fc0f715fdbcc6
-  data.tar.gz: b660d0b89243e6a676853738e89729f666c2c4a0
+  metadata.gz: 23e2d866a0c76bc981182646dbb7c459eddc15c5
+  data.tar.gz: f648dcf434fb3f57deba0f2950a47b15cef095e7
 SHA512:
-  metadata.gz: 7dd59c3e0aa6b2e0320226c11c849681a168070d759db2a89d2d4d6012994d775051529cdf3293b94d65d7fc3ccf8e28d0996ab55465e348b50707adcf597bba
-  data.tar.gz: fe13cd37f6f736a872a6d2c8b48b10a9079580832c48323cec5e5a5f2f95bd8a3320ffac17a83ed5b45319973e905a563190fdc475895ddafa9c4b4df06eb7fc
+  metadata.gz: 05ae4e8cadf51c767c005cb03f2e0bf3b164903ad39d371560b5388f99ca9036cf2aaf21d15e10d3f732ed43bc2b951ec87c0283917a3404704225304a7b52ef
+  data.tar.gz: 34236b528e312e5b0617cc0d5a6b3d76a29215fb244b11294850baa0c65189c090640bdbeeaa5491102ee050a689ef98fe73e873539d4493c1fdb254605296a1

data/.gitignore

@@ -48,3 +48,7 @@ Gemfile.lock
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+
+lib/rubex/parser.output
+lib/rubex/parser.tab.rb
+/.idea/

data/.travis.yml

@@ -0,0 +1,14 @@
+language:
+  ruby
+
+rvm:
+  - '2.2'
+  - '2.3.0'
+  - '2.4.0'
+
+script:
+  - bundle exec rake spec
+
+install:
+  - gem install bundler
+  - bundle install

data/CONTRIBUTING.md

@@ -0,0 +1,101 @@
+# Table of Contents
+
+<!-- MarkdownTOC autolink="true" bracket="round" -->
+
+- [Setup](#setup)
+- [Development notes](#development-notes)
+- [Important data representations](#important-data-representations)
+- [Internals](#internals)
+  - [Attach classes](#attach-classes)
+- [Future work](#future-work)
+
+<!-- /MarkdownTOC -->
+
+# Setup
+
+If you wish to contribute to Rubex, you can setup rubex on your system with the following commands:
+```
+bundle install
+rake install
+```
+
+Then you can compile a Rubex file with this:
+```
+rubex file_name.rubex
+```
+
+# Development notes
+
+Couple of conventions that I followed when writing the code:
+* All the statements contain methods:
+  - analyse_statement(local_scope)
+  - generate_code(code, local_scope)
+* Expressions contain methods:
+  - analyse_statement(local_scope)
+  - c_code(local_scope)
+
+Sometimes it can so happen that an expression can consist simply of a single variable (like `if (a)`) or be a full expression (like `if (a == b)`). In the first case, the `a` is just read as an `IDENTIFIER` by the parser. In the second case, `a == b` is read as an `expr` and is stored in the AST as `Rubex::AST::Expression`.
+
+Now you might be thinking why expressions should also have a `analyse_statement` method, that's just for maintaining uniformity between exprs and stmts (maybe that should be just `analyse`?).
+
+When writing the `<=>` operator under Rubex::DataType classes, I have been forced to assume that `Int` is 32 bits long since I have not yet incorporated a way to figure out the number of bits used by a particular machine for representing an `int`. It will be changed later to make it machine-dependent.
+
+# Important data representations
+
+### Data format for holding parsed variables in declarations and arguments
+
+This consists of a hash that looks like this:
+```
+{ 
+  dtype: ,
+  variables: [{}]
+}
+```
+
+The `:variables` field might be `nil` in case of a function declaration in which case it is not necessary to specify the name of the variable.
+
+The `:variables` key maps to a value that is an Array of Hashes that contains a single Hash:
+```
+{
+  ptr_level:,
+  value:,
+  ident: identity
+}
+```
+
+`identity` can be a Hash in case of a function pointer argument, or a simple String in case its an identifier, or an `ElementRef` if specifying an array of elements.
+
+If Hash, it will look like this:
+```
+{    
+  name:,
+  return_ptr_level:,
+  arg_list:
+}
+```
+
+# Internals
+
+## Attach classes
+
+
+
+# Future work
+
+The following features in Rubex need to be implemented or can be made better:
+
+* Ability to have Ruby-style method arguments without parenthesis.
+* Multiline conditionals in the condition of if-elsif statements.
+* Special treatment for VALUE C arrays by marking each element with GC.
+* Checks for return statement. No return statement or wrong return type should raise error/warning.
+* Compile time checking of types passed into functions and methods.
+* Perform type checks in C before implicit conversion between Ruby and C types.
+* Ability to define function at any location in the file witout caring for when it will be actually used.
+* Error checking for dereferencing of void pointer.
+* Prohibit structs (vector types) in if statements via compile time checks.
+* Ability to provide default values to method arguments.
+* Ability to write Rubex programs spanning multiple files.
+* If a Ruby method and extern C function have the same name the program malfunctions. Either namespace C functions or disallow Ruby methods with same names as extern C functions.
+* Clean up classes under Statement such that they don't have attr_reader's like `:name` and `:type` which are really not a part of statement attributes.
+* Support for multi-file programs (maybe using `require`?).
+* Refactor classes to cleaner support for compound types like CFunctions and simple struct pointers that have the base type nested just one level deep.

data/HISTORY.md

@@ -0,0 +1,3 @@
+# v0.1 (17 Sept. 2017)
+
+* First release.

data/README.md

@@ -1,343 +1,158 @@
-# rubex
-rubex - A Crystal-inspired language for writing Ruby extensions.
+# Rubex
 
-# Background
+Rubex is a Ruby-like language for writing Ruby C extensions.
 
-Rubex aims to make writing C extensions as intuitive as writing Ruby code. A very simple example would be a recursive implementation of a function that computes the factorial of a given number. The method for this is called `factorial` and the class in which it resides is called `Fact`. The code in rubex would like this:
-``` ruby
-class Fact
-  def factorial(i64 n)
-    return (n > 1 ? n*factorial(n-1) : 1)
-  end
-end
-```
+Rubex is a language that makes writing CRuby C extensions as simple as writing Ruby. It does this by providing a syntax that is the perfect blend of the elegance of Ruby and the power of C. Rubex compiles to C and implicitly interfaces with the Ruby VM in a manner that is completely transparent to the programmer.
 
-The rubex compiler will compile this code into the equivalent C code, and also make the appropriate calls to the CRuby C API which will perform interconversions between Ruby and C data types and register the class and it's instance method with the interpreter using the appropriate calls to `rb_define_class()` and `rb_define_method()`.
+Rubex keeps you happy even when writing C extensions.
 
-Making C extensions in this manner will GREATLY simply the process, and allow for more succint and readable extensions that look very similar to Ruby. To actually see exactly how simple writing extensions will become, the current way of writing the same `factorial` function in the `Fact` class would look something like this with pure C code:
-``` c
-#include <ruby.h>
+# Status
 
-int
-calc_factorial(int n)
-{
-  return (n > 1 ? n*calc_factorial(n-1) : 1);
-}
-
-static VALUE
-cfactorial(VALUE self, VALUE n)
-{
-  return INT2NUM(calc_factorial(NUM2INT(n)));
-}
-
-void Init_factorial()
-{
-  VALUE cFact = rb_define_class("Fact", rb_cObject);
-  rb_define_method(cFact, "factorial", cfactorial, 1);
-}
-```
+[![Gem Version](https://badge.fury.io/rb/rubex.svg)](https://badge.fury.io/rb/rubex)
 
-Now imagine growing this to solving a non-trivial problem, and the benefits imparted by rubex in terms of productivity and simplicity become increasingly apparent. Users will simply need to call a command or rake task that will generate the relevant C code and create a shared object binary, that can be then imported into any Ruby program with a call to `require`.
+# Table of Contents
 
-# Syntax specification
+<!-- MarkdownTOC autolink="true" bracket="round"-->
 
-WARNING: Specification set to change!
+- [Quick Introduction](#quick-introduction)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Tutorial](#tutorial)
+- [Syntax](#syntax)
+- [Roadmap](#roadmap)
+- [Acknowledgements](#acknowledgements)
 
-#### File extensions
+<!-- /MarkdownTOC -->
 
-Rubex files will have a `.rubex` file extension.
+# Quick Introduction
 
-#### Comments
-
-Rubex will only support single line comments in lines that start with a `#` character, just like Ruby.
-
-#### Line termination
-
-A line of code can be terminated with a newline (`\n`) character.
-
-#### Support for C data types
-
-The above example demonstrated the factorial function being used with a 64 bit integer data type, and rubex will support many such data types. The keywords for these data types will be borrowed from Crystal, and they will be translated to the corresponding C types with the rubex compiler. For the first version (v0.1) the following data types will be supported:
-
-|rubex keyword         | C type | Description  |
-|:---                  |:---    |:---          |
-|char                  |char        |Character              |
-|i8                    |int8_t        |8 bit integer |
-|i16                   |int16_t        |16 bit integer              |
-|i32                   |int32_t        |32 bit integer              |
-|i64                   |int64_t        |64 bit integer              |
-|u8                    |uint8_t        |8 bit  unsigned integer               |
-|u16                   |uint16_t        |16 bit unsigned integer              |
-|u32                   |uint32_t        |32 bit unsigned integer              |
-|u64                   |uint64_t        |64 bit unsigned integer              |
-|int                   |int  | Integer >= 16 bits. |
-|unsigned int          |unsigned int| Unsigned integer >= 16 bits. |
-|long int              |long int| Integer >= 32 bits.|
-|unsigned long int     |unsigned long int|Unsigned Integer >= 32 bits. |
-|long long int         |long long int|Integer >= 64 bits.|
-|unsigned long long int|unsigned long long int|Unsigned Integer >= 64 bits.|
-|f32/float             |float        |32 bit floating point              |
-|f64/double            |double        |64 bit floating point              |
-|long f64/long double  |long double|Long double >= 96 bits. |
-|object                |VALUE        |Ruby object |
-
-Variables with these data types can be declared by writing the data type keyword before the variable name, and will not follow the Crystal convention. So for example, to declare some integers and floats in rubex, you would do this:
-```
-i32 int_number
-f64 float_number
-i8 u, i = 33
-```
-I will use the `stdint.h` header file that provides support for declaring integer types of precise bit length.
-
-#### Structs
-
-You can define your own C structures using the `struct` keyword. It can contain any sort of data type inside it, just like structs in C. It can also contain references and pointers to itself. To create a struct called 'Node', you can use the following syntax:
-```
-struct Node do
-  int data
-  struct Node* next
+Consider this Ruby code for computing a fibonnaci series and returning it in an Array:
+``` ruby
+class Fibonnaci
+  def compute(n)
+    i = 1, prev = 1, current = 1, temp
+    arr = []
+
+    while i < n do
+      temp = current
+      current = current + prev
+      prev = temp
+      arr.push(prev)
+      i += 1
+    end
+
+    arr
+  end
 end
-# C equivalent:
-# struct Node {
-#   int data;
-#   struct Node* next;    
-# };
 ```
-Varibles of type `Node` can be declared by using `struct Node`, like `struct Node foo`, or pointers with `Pointer(struct Node)` or `struct Node*`.
 
-#### Typedefs
-
-The `struct` in the example above can also be aliased with the `alias` keyword. The function of `alias` is similar to `typedef` in C. So `alias Node = struct Node` will declarations in the form of `Node foo`. Once a type has been aliased, the original name (`struct Node`) can be used interchangably with the new name (`Node`).
-
-#### Unions
+If you decide to port this to a C extension, the code will look like so:
+``` c
+#include <ruby.h>
+#include <stdint.h>
 
-A C union can be defined with the `union` keyword similar to the way a `struct` is declared. For example,
-```
-union IntAndFloat do
-  i32 a
-  f32 b
-end
-```
+void Init_a ();
+static VALUE Fibonnaci_compute (int argc,VALUE* argv,VALUE self);
 
-The `union` must either be aliased to some other user-defined type or must be reffered to by the `union` keyword. So a variable of the above union will be declared as `union IntAndFloat intfloat`.
+static VALUE Fibonnaci_compute (int argc,VALUE* argv,VALUE self)
+{
+  int n,i,prev,current,temp;
+  VALUE arr;
+
+  if (argc < 1) {
+    rb_raise(rb_eArgError, "Need 1 args, not %d", argc);
+  }
+
+  n       = NUM2INT(argv[0]);
+  i       = 1;
+  prev    = 1;
+  current = 1;
+  arr     = rb_ary_new2(0);
+
+  while (i < n)
+  {
+    temp = current;
+    current = current + prev;
+    prev = temp;
+    rb_funcall(arr, rb_intern("push"), 1 ,INT2NUM(prev));
+    i = i + 1;
+  }
+
+  return arr;
+}
 
-#### Enums
+void Init_a ()
+{
+  VALUE cls_Fibonnaci;
 
-A C `enum` can be declared with the `enum` keyword. Each element in the enum will be separated by newlines (`\n`) or commas (`,`), and default values starting from `0` will be assigned to successive enum elements. For example,
-```
-enum Week do
-  monday
-  tuesday
-  wednesday
-  thursday
-  friday
-  saturday
-  sunday
-end
-```
+  cls_Fibonnaci = rb_define_class("Fibonnaci", rb_cObject);
 
-The default values can be changed with an assignment:
-```
-enum SomeEnum do
-  one = 3,
-  two = 5,
-end
+  rb_define_method(cls_Fibonnaci ,"compute", Fibonnaci_compute, -1);
+}
 ```
 
-#### Functions
-
-There can basically be two types of functions that will need to be defined in rubex:
-
-* _Pure Ruby methods_ that take a Ruby object as the first argument (the `VALUE` in C extensions, see the `cfactorial` method in the above example) and return a Ruby object.
-* _C methods_ that purely take C data types as input and return a C data type (for example the `calc_factorial` function in the above example).
-
-These two kinds of methods will have slightly different syntax when it comes to defining methods. Let me elaborate on them both:
-
-**Pure Ruby Methods**
-
-These will be defined just like normal Ruby methods, but will support typed formal parameters. Internally they will be translated to functions that accept `VALUE` as the first argument and return `VALUE`.
-
-To define a method of this kind, the user can use syntax that looks like this:
+However, if you decide to write a C extension using Rubex, the code will look like this!:
 ``` ruby
-def plus_one(f32 n)
-  n + 1
-end
-```
-
-When a parameter of a Ruby method is declared to have a C type, it passed a Ruby object, which is then converted to a C value if possible. If the data type is not speicified, the function will take a Ruby object as an argument.
-
-ONLY THESE METHODS WILL BE CALLABLE FROM INTERPRETED RUBY CODE. 
-
-**Pure C Methods**
-
-These are methods that are only callable from C code. They cannot be called directly from interpreted Ruby code.
-
-They also look very similar to the pure Ruby methods, but have a caveat that they must be defined with `cdef` instead of `def` and should also specify a return data type. These methods must specify the type of their formal arguments. Therefore, the syntax for writing a simple addition function would look like this:
-``` ruby
-cdef f32 plus_one(f32 n)
-  n + 1
+class Fibonnaci
+  def compute(int n)
+    int i = 1, prev = 1, current = 1, temp
+    array = []
+
+    while i < n do
+      temp = current
+      current = current + prev
+      prev = temp
+      array.push(prev)
+      i += 1
+    end
+
+    return array
+  end
 end
 ```
-In above example, the function `plus_one` takes a 32 bit floating point number `n` as an argument and returns a 32 bit floating point number after adding `1` to it. If a return type is not specified for a C function, it is assumed to be `VALUE` (Ruby object).
-
-These functions will also be compiled such that the last line is actually the return statement, as is the case in Ruby. Pure C methods will only be callable from rubex and cannot be called by external interpreted Ruby code.
-
-**Passing functions to other functions**
-
-C functions (i.e. those defined with the `cdef` keyword) can be passed to other functions, just like C function pointers. If a C method accepts a function of a particular type signature it can be specified with the `Function()` keyword. The last argument to the `Function()` keyword is the return type of that function. The functionality can also be realized by specifying the function as `input parameters type -> return type`.
-
-For example, a function that accepts two arguments, one of type `i32` and the other of type `f64` and returns a varible of type `i32` can be specified by either `Function(i32,f64,i32)` or `i32, f64 -> i32`.
-
-#### Variables
-
-Any variable can have the `extern` or `static` keyword associated with it in order to declare it so.
-
-#### Pointers
-
-Rubex will allow declaring pointers with either the `*` operator or the `Pointer()` keyword. For example, an `i32` pointer can be declared as either `*i32` or `Pointer(i32)`. Notice that the 'P' of `Pointer()` is in capitals. This notation will be followed for all compiler directives that take arguments.
-
-#### Literals
-
-Several literals will be available for creating many basic types in the language. I have listed some of the major ones below:
-
-* **nil** - This (`nil`) represent's Ruby's NilClass object, and will be translated to the `Qnil` Ruby constant according to the C API.
-* **Boolean values** - `true` and `false` are the literals for boolean values and will be translated to `Qtrue` and `Qfalse` by the compiler.
-* **Integers** - Rubex will not make any assumptions about variables without an associated type assigned to integers. Thus, in order to create C integers, users must specify the data type of the variable. Therefore, `i = 3` will lead to `i` being compiled as a Ruby `Fixnum` object, and `i32 i = 3` will compile to a C 32 bit integer as `int32_t i = 3`.
-* **Floats** - The assumptions made for integers will apply to floats as well.
-* **Character** - Character `char` literals can be specified by enclosing the character in single quotes (`'` and `'`). These are equivalent to character literals in C.
-* **Strings** - String literals are enclosed inside double quotes (`"` and `"`). When assigning a string literal to a variable, the variable must be of type `char*`. If the type is not specified, it will be treated as a Ruby string.
-* **Symbol** - Rubex symbols use the exact same syntax as Ruby symbols, and will be directly translated to the relevant C API function for creating symbols.
-
-#### Arrays
-
-C arrays of a definite size (static arrays) can be specified using square brackets after the variable name. For example, to declare an array of 10, 16-bit integers, the syntax would be `i16 arr[10]`. Static arrays can also be declared with the `StaticArray()` keyword. Thus, to declare a C static array of `i8` of size `8`, you can either use`StaticArray(i8, 8)` or `i8[8]`.
-
-If a Ruby array is specified using Ruby's Array literal syntax (`[]`), it will be directly translated into a Ruby Array object. For example the statement `a = []` will store a Ruby Array object in the variable 'a'.
-
-Static arrays can be initialized with Ruby's array literal syntax. So for example, you can initiazile an array of 10 `i16` integers like this:
-```
-i16 a[10] = [1,2,3,4,5,6,7,8,9,10]
-# C equivalent -> int16_t a[10] = {1,2,3,4,5,6,7,8,9,10};
-```
 
-#### Loops
+Notice the only difference between the above Rubex code and Ruby is the specification of explicit `int` types for the variables. Above Rubex code will automatically compile into C code and will also implicitly interface with the Ruby VM without you having to remember any of the APIs.
 
-Rubex will itself define a `for` loop for performing integer iterations. The syntax for this will be as follows:
-```
-i32 i, s = 0, m = 10
-for s < i <= m do
-  # code
-end
-```
+Rubex also takes care of the initial setup and compilation of the C files, so all you need to do is execute a bunch of commands and your extension is up and running!
 
-If the loop variable `i` and lower and upper bounds are all C integer expressions, this loop will be directly compiled into a C for-loop and will be very fast. The direction of the iteration is determined by the relations. If they are from the `{<,<=}` the iteration is upwards, or if they are from the set `{>,>=}`, the iteration is downwards.
+# Installation
 
-Rubex can also translate `.each` method called on `StaticArray` into the equivalent C `for` loops. The only caveat being that since there's no way to dynamically determine the length of C arrays, an argument (an integer) will need to be passed into the `.each` method that will tell Rubex the lenghth. To demonstrate:
+The gem as of now has not reached v0.1. However, you can try it out with:
 ```
-i16 a[10] = [1,2,3,4,5,6,7,8,9,10]
-
-a.each(10) do |x|
-  # do something...
-end
-
-# C equivalent:
-# int size = 10
-# for(int i = 0; i < size; i++) {
-#   i16 x = a[i]
-#   // do something....
-# }
+git clone https://github.com/v0dro/rubex.git
+cd rubex
+bundle install
+rake install
 ```
 
-#### Wrapping C functions
-
-This is the most important functionality of rubex. A lot of it will be borrowed from Crystal since Crystal's API for creating C bindings is very well thought out and simple.
-
-**lib**
+# Usage
 
-For interfacing any C library with Ruby, rubex will provide the `lib` keyword. The `lib` declaration will basically group C functions and types that belong to a particular library. For example,
+Installing the gem will also install the `rubex` binary. You can now write a Rubex file (with a `.rubex` file extension) and compile it into C code with:
 ```
-#@[Link("pcre")]
-lib LibPCRE
-end
+rubex file_name.rubex
 ```
 
-The syntax above the `lib` declaration is a special 'magic comments' syntax. The presence of `@[...]` after the `#` of the comments will allow the Rubex compiler to know that the comment is not a regular comment but is actually a directive for an operation that is to be performed by the compiler. 
-
-The `Link` keyword inside the `@[...]` syntax of the magic comment will ensure that appropriate flags are passed to the compiler to find the external libraries. So for example, it the above case, the `Link("pcre")` directive will `-lpcre` to the linker.
-
-If `Link(ldflags: "...")` is passed into the magic comment, those flags will be passed directly to the linker, without any modification, for example `Link(ldflags: "-lpcre")`. Enclosing those commands inside backticks will execute those commands, for example `Link(ldflags: "`pkg-config libpcre --libs`")`.
-
-**require_header**
-
-The `require_header` keyword will include C headers in the generated C code. For example `require_header 'math'` will put a statement `#include <math.h>`.
-
-**fun**
-
-A `fun` declaration will bind a C function.
+This will produce the translated C code and an `extconf.rb` file inside a directory called `file_name`. CD into the directory, and run the `extconf.rb` file with:
 ```
-require_header 'math'
-
-class Maths
-  def cos(f32 v)
-    CMath.cos(v)
-  end
-end
-
-lib CMath
-  fun f32 cos(f32 value)
-end
+ruby extconf.rb
 ```
-The user can the call the `cos` function from Ruby with `Maths.new.cos(0.7)`. Calls to `fun` must be inside a `lib` block. This facilitates easy linking and namespacing of C bindings.
 
-The parentheses can be omitted if the function does not accept arguments:
-```
-# In rubex
-lib C
-  fun i32 getch
-end
+This will produce a `Makefile`. Run `make` to compile the generated C file and generate a `.so` shared object file that can be used in any Ruby script.
 
-# In Ruby
-C.getch
-```
-If the return type is `void` you can omit it:
-```
-# In Rubex
-lib C
-  fun srand(u32 seed)
-end
+# Tutorial
 
-# In Ruby
-C.srand(1)
-```
+Give yourself 5 min and go through the [TUTORIAL](TUTORIAL.md). Convert a part of your C extension to Rubex and see the jump in cleanliness and productivity for yourself.
 
-Functions with variable arguments can also be bound:
-```
-# In Rubex
-lib X
-  fun i32 variadic(i32 value, ...)
-end
+# Syntax
 
-# In Ruby
-X.variadic(1, 2, 3, 4)
-```
+Read the full Rubex reference in [REFERENCE](REFERENCE.md).
 
-If a function starts with a name that you don't want to use in your Ruby program, or if it contains characters that cannot be used in Ruby methods, you can assign it a different name with `=`. For example,
-```
-lib C
-  fun cosine = f32 cos(f32 value)
-end
-```
-Or say the function starts with a capital letter (which is a constant in Ruby and is confusing to use as a method name) or contains an invalid character like `.`, in which case you can wrap it in a string:
-```
-lib LibSDL
-  fun init = u32 SDL_Init(u32 flags)
-end
+# Roadmap
 
-lib LLVMIntrinsics
-  fun ceil_f32 = f32 "llvm.ceil.f32"(f32 value) 
-end
-```
+See the [CONTRIBUTING](CONTRIBUTING.md) and the GitHub issue tracker for future features.
 
-#### Embedding C code
+# Acknowledgements
 
-If you must write C, you can do that with a `%{ ... %}` block or a `BEGIN_C do ... end` block.
+* The Ruby Association (Japan) for providing the initial funding for this project through the Ruby Association Grant 2016.
+* Koichi Sasada (@ko1) and Kenta Murata (@mrkn) for their support and mentorship throughout this project.
+* Fukuoka Ruby Award 2017.