slow_blink 0.0.2 → 0.0.3

data/test/tc_model_encode.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2016 Cameron Harper
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#  
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require "test/unit"
+require 'slow_blink'
+
+class TestModelEncode < Test::Unit::TestCase
+
+    include SlowBlink
+
+    def test_think_blink
+        rawSchema = <<-eos
+        OrderExecuted/0x4c ->
+            string Symbol,
+            u64 OrderId,
+            u32 Price,
+            u32 Qty,
+            u8 MatchId
+        eos
+        schema = Schema.new(SchemaBuffer.new(rawSchema))        
+    
+        model = Message::Model.new(schema)                
+        message = model.new do
+            group "OrderExecuted" do |g|
+                g["Symbol"] = "hey"
+                g["OrderId"] = 42 
+                g["Price"] = 42 
+                g["Qty"] = 42 
+                g["MatchId"] = 42                
+            end            
+        end
+
+        assert_equal("hey", message["Symbol"])
+        assert_equal(42, message["OrderId"])
+        assert_equal(42, message["Price"])
+        assert_equal(42, message["Qty"])
+        assert_equal(42, message["MatchId"])
+
+        output = message.to_compact
+        
+        expected = "\x09\x4c\x03hey\x2a\x2a\x2a\x2a"
+
+        assert_equal(expected, output)
+
+    end
+
+end

data/test/tc_namespace.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require 'slow_blink'
+
+class TestNamespace < Test::Unit::TestCase
+
+    include SlowBlink
+
+end

data/test/tc_types.rb

@@ -0,0 +1,198 @@
+# Copyright (c) 2016 Cameron Harper
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#  
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require "test/unit"
+require 'slow_blink'
+
+class TestTypes < Test::Unit::TestCase
+
+    include SlowBlink
+
+    def test_bool
+        input = "test -> bool test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(BOOLEAN, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_u8
+        input = "test -> u8 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(U8, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_u16
+        input = "test -> u16 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(U16, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_u32
+        input = "test -> u32 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(U32, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_u64
+        input = "test -> u64 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(U64, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_i8
+        input = "test -> i8 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(I8, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_i16
+        input = "test -> i16 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(I16, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_i32
+        input = "test -> i32 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(I32, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_i64
+        input = "test -> i64 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(I64, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_f64
+        input = "test -> f64 test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(FLOATING_POINT, schema.ns[nil].group("test").field("test").type.class)
+    end
+
+    def test_string_without_size
+        input = "test -> string test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(STRING, schema.ns[nil].group("test").field("test").type.class)
+        assert_equal(nil, schema.ns[nil].group("test").field("test").type.size)        
+    end
+
+    def test_string_with_size
+        input = "test -> string (42) test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(STRING, schema.ns[nil].group("test").field("test").type.class)
+        assert_equal(42, schema.ns[nil].group("test").field("test").type.size)       
+    end
+    
+    def test_binary_without_size
+        input = "test -> binary test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(BINARY, schema.ns[nil].group("test").field("test").type.class)
+        assert_equal(nil, schema.ns[nil].group("test").field("test").type.size)        
+    end
+
+    def test_binary_with_size
+        input = "test -> binary (42) test "
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(BINARY, schema.ns[nil].group("test").field("test").type.class)        
+        assert_equal(42, schema.ns[nil].group("test").field("test").type.size)
+    end
+
+    def test_fixed
+        input = "test -> fixed (42) test "
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(FIXED, schema.ns[nil].group("test").field("test").type.class)        
+        assert_equal(42, schema.ns[nil].group("test").field("test").type.size)
+    end
+
+    def test_enum
+        input = "colour = | blue"
+        schema = Schema.new(SchemaBuffer.new(input))
+    end
+
+    def test_enum_many
+        input = "colour = blue | white | red/5"
+        schema = Schema.new(SchemaBuffer.new(input))
+    end
+
+    def test_ref_enum
+        input = "colour = | blue test -> colour test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(REF, schema.ns[nil].group("test").field("test").type.class)
+        assert_equal(ENUMERATION, schema.ns[nil].group("test").field("test").type.ref.class)
+        assert_equal("blue", schema.ns[nil].group("test").field("test").type.ref.symbol("blue").name)
+        assert_equal(0, schema.ns[nil].group("test").field("test").type.ref.symbol("blue").val)        
+    end
+
+    def test_ref_enum_many
+        input = "colour = blue | white | red/5 | orange test -> colour test"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal(REF, schema.ns[nil].group("test").field("test").type.class)
+        assert_equal(ENUMERATION, schema.ns[nil].group("test").field("test").type.ref.class)
+        assert_equal("blue", schema.ns[nil].group("test").field("test").type.ref.symbol("blue").name)
+        assert_equal(0, schema.ns[nil].group("test").field("test").type.ref.symbol("blue").val)        
+        assert_equal("white", schema.ns[nil].group("test").field("test").type.ref.symbol("white").name)
+        assert_equal(1, schema.ns[nil].group("test").field("test").type.ref.symbol("white").val)        
+        assert_equal("red", schema.ns[nil].group("test").field("test").type.ref.symbol("red").name)
+        assert_equal(5, schema.ns[nil].group("test").field("test").type.ref.symbol("red").val)        
+        assert_equal("orange", schema.ns[nil].group("test").field("test").type.ref.symbol("orange").name)
+        assert_equal(6, schema.ns[nil].group("test").field("test").type.ref.symbol("orange").val)        
+    end
+
+    def test_static_group
+        input = "static -> u8 one, u16 two test -> static one, string two"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal("one", schema.ns[nil].group("test").field("one").nameWithID.name)
+        assert_equal(REF, schema.ns[nil].group("test").field("one").type.class)
+        assert_equal(false, schema.ns[nil].group("test").field("one").type.dynamic?)
+        assert_equal("two", schema.ns[nil].group("test").field("two").nameWithID.name)
+        assert_equal(STRING, schema.ns[nil].group("test").field("two").type.class)
+        assert_equal("one", schema.ns[nil].group("test").field("one").type.ref.field("one").nameWithID.name)
+        assert_equal(U8, schema.ns[nil].group("test").field("one").type.ref.field("one").type.class)
+        assert_equal("two", schema.ns[nil].group("test").field("one").type.ref.field("two").nameWithID.name)
+        assert_equal(U16, schema.ns[nil].group("test").field("one").type.ref.field("two").type.class)        
+    end
+
+    def test_dynamic_group
+        input = "dynamic -> u8 one, u16 two test -> dynamic * one, string two"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal("one", schema.ns[nil].group("test").field("one").nameWithID.name)
+        assert_equal(REF, schema.ns[nil].group("test").field("one").type.class)
+        assert_equal(true, schema.ns[nil].group("test").field("one").type.dynamic?)
+        assert_equal("two", schema.ns[nil].group("test").field("two").nameWithID.name)
+        assert_equal(STRING, schema.ns[nil].group("test").field("two").type.class)
+        assert_equal("one", schema.ns[nil].group("test").field("one").type.ref.field("one").nameWithID.name)
+        assert_equal(U8, schema.ns[nil].group("test").field("one").type.ref.field("one").type.class)
+        assert_equal("two", schema.ns[nil].group("test").field("one").type.ref.field("two").nameWithID.name)
+        assert_equal(U16, schema.ns[nil].group("test").field("one").type.ref.field("two").type.class)        
+    end
+
+    def test_dynamic_not_group
+        input = "thing = u8 one test -> thing * one, string two"
+        assert_raise do
+           Schema.new(SchemaBuffer.new(input))
+        end
+    end
+
+    def test_any_group
+        input = "dynamic -> u8 one, u16 two test -> object one, string two"
+        schema = Schema.new(SchemaBuffer.new(input))
+        assert_equal("one", schema.ns[nil].group("test").field("one").nameWithID.name)
+        assert_equal(OBJECT, schema.ns[nil].group("test").field("one").type.class)        
+    end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slow_blink
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Cameron Harper
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-21 00:00:00.000000000 Z
+date: 2016-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -57,36 +57,75 @@ email: contact@cjh.id.au
 executables: []
 extensions:
 - ext/slow_blink/ext_schema_parser/extconf.rb
+- ext/slow_blink/ext_compact_encoder/extconf.rb
 extra_rdoc_files: []
 files:
+- ext/slow_blink/ext_compact_encoder/compact_encoder.c
+- ext/slow_blink/ext_compact_encoder/compact_encoder.h
+- ext/slow_blink/ext_compact_encoder/ext_compact_encoder.c
+- ext/slow_blink/ext_compact_encoder/extconf.rb
 - ext/slow_blink/ext_schema_parser/common.h
 - ext/slow_blink/ext_schema_parser/extconf.rb
 - ext/slow_blink/ext_schema_parser/lexer.c
 - ext/slow_blink/ext_schema_parser/lexer.h
 - ext/slow_blink/ext_schema_parser/parser.c
 - ext/slow_blink/ext_schema_parser/parser.h
-- ext/slow_blink/ext_schema_parser/parser.l
-- ext/slow_blink/ext_schema_parser/parser.y
 - lib/slow_blink.rb
 - lib/slow_blink/annotatable.rb
 - lib/slow_blink/annotation.rb
+- lib/slow_blink/binary.rb
+- lib/slow_blink/boolean.rb
 - lib/slow_blink/compact_encoder.rb
-- lib/slow_blink/component_reference.rb
+- lib/slow_blink/date.rb
+- lib/slow_blink/decimal.rb
 - lib/slow_blink/definition.rb
 - lib/slow_blink/enumeration.rb
 - lib/slow_blink/error.rb
 - lib/slow_blink/field.rb
+- lib/slow_blink/fixed.rb
+- lib/slow_blink/floating_point.rb
 - lib/slow_blink/group.rb
 - lib/slow_blink/incremental_annotation.rb
-- lib/slow_blink/message.rb
+- lib/slow_blink/integer.rb
+- lib/slow_blink/message/binary.rb
+- lib/slow_blink/message/boolean.rb
+- lib/slow_blink/message/date.rb
+- lib/slow_blink/message/decimal.rb
+- lib/slow_blink/message/enumeration.rb
+- lib/slow_blink/message/field.rb
+- lib/slow_blink/message/fixed.rb
+- lib/slow_blink/message/floating_point.rb
+- lib/slow_blink/message/group.rb
+- lib/slow_blink/message/integer.rb
+- lib/slow_blink/message/model.rb
+- lib/slow_blink/message/sequence.rb
+- lib/slow_blink/message/string.rb
+- lib/slow_blink/message/time.rb
+- lib/slow_blink/message/time_of_day.rb
 - lib/slow_blink/name_with_id.rb
+- lib/slow_blink/namespace.rb
+- lib/slow_blink/object.rb
+- lib/slow_blink/ref.rb
 - lib/slow_blink/schema.rb
+- lib/slow_blink/schema_buffer.rb
+- lib/slow_blink/sequence.rb
+- lib/slow_blink/string.rb
 - lib/slow_blink/sym.rb
+- lib/slow_blink/time.rb
+- lib/slow_blink/time_of_day.rb
 - lib/slow_blink/type.rb
 - lib/slow_blink/version.rb
 - rakefile
-- test/integration/capture_stderr.rb
-- test/integration/tc_inputs.rb
+- test/capture_stderr.rb
+- test/tc_compact_encoder.rb
+- test/tc_field.rb
+- test/tc_group.rb
+- test/tc_incr_annote.rb
+- test/tc_inputs.rb
+- test/tc_model.rb
+- test/tc_model_encode.rb
+- test/tc_namespace.rb
+- test/tc_types.rb
 homepage: https://github.com/cjhdev/slow_blink
 licenses:
 - MIT
@@ -110,8 +149,16 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Blink Protocol in Ruby (placeholder)
+summary: Blink Protocol in Ruby
 test_files:
-- test/integration/tc_inputs.rb
-- test/integration/capture_stderr.rb
+- test/tc_compact_encoder.rb
+- test/tc_group.rb
+- test/tc_inputs.rb
+- test/tc_model_encode.rb
+- test/tc_namespace.rb
+- test/tc_types.rb
+- test/capture_stderr.rb
+- test/tc_model.rb
+- test/tc_field.rb
+- test/tc_incr_annote.rb
 has_rdoc: yard

data/ext/slow_blink/ext_schema_parser/parser.l

@@ -1,139 +0,0 @@
-/* Blink Protocol Flex Configuration
- *
- * Cameron Harper 2016
- *
- * */
-%{
-
-/* includes ***********************************************************/
-
-#include <float.h>
-#include <ruby.h>
-#include "parser.h"
-
-/* static prototypes **************************************************/
-
-/**
- * - Inserted into lexer as part of the YY_USER_ACTION macro
- * - 
- * 
- * @param[in] loc pointer to Bison location record
- * @param[in] text
- * @param[in] textLen length of text in bytes
- *
- * */
-static void updateLocation(YYLTYPE *loc, const char *text, int textLen);
-
-/* macros *************************************************************/
-
-#define YY_USER_ACTION updateLocation(yylloc, yytext, yyleng);
-
-/* generated **********************************************************/
-
-%}
-
-%top{
-
-    #include "common.h"
-
-}
-
-%option nounput
-%option noinput
-%option bison-bridge bison-locations
-%option reentrant
-%option noyywrap
-%option debug
-
-
-%x LITERAL_C
-%x LITERAL_A
-
-%%
-
-"#"[^\r\n]*        { /* skip comments */ }
-
-"\""                { BEGIN(LITERAL_C); }
-<LITERAL_C>[^\"]*   { *yylval = rb_str_new(yytext, yyleng); return TOK_LITERAL; }
-<LITERAL_C>"\""     { BEGIN(INITIAL); }
-
-"'"                 { BEGIN(LITERAL_A); }
-<LITERAL_A>[^']*    { *yylval = rb_str_new(yytext, yyleng); return TOK_LITERAL; }
-<LITERAL_A>"'"      { BEGIN(INITIAL); }
-
-"="                 |
-","                 |
-"?"                 |
-"["                 |
-"]"                 |
-"("                 |
-")"                 |
-"*"                 |
-"|"                 |
-"."                 |
-"/"                 |
-"@"                 |
-":"                 { return *yytext; }
-
-"i8"                { return TOK_I8; }  
-"i16"               { return TOK_I16; }
-"i32"               { return TOK_I32; }
-"i64"               { return TOK_I64; }
-"u8"                { return TOK_U8; }
-"u16"               { return TOK_U16; }
-"u32"               { return TOK_U32; }
-"u64"               { return TOK_U64; }
-"f64"               { return TOK_F64; }
-"decimal"           { return TOK_DECIMAL; }
-"date"              { return TOK_DATE; }
-"timeOfDayMilli"    { return TOK_TIME_OF_DAY_MILLI; }
-"timeOfDayNano"     { return TOK_TIME_OF_DAY_NANO; }
-"nanotime"          { return TOK_NANO_TIME; }
-"millitime"         { return TOK_MILLI_TIME; }
-"bool"              { return TOK_BOOLEAN; }
-"string"            { return TOK_STRING; }
-"object"            { return TOK_OBJECT; }
-"namespace"         { return TOK_NAMESPACE; }
-"type"              { return TOK_TYPE; }
-"schema"            { return TOK_SCHEMA; }
-"number"            { return TOK_NUMBER; }
-"fixed"             { return TOK_FIXED; }
-"binary"            { return TOK_BINARY; }
-
-"->"                { return TOK_RIGHT_ARROW; }
-"<-"                { return TOK_LEFT_ARROW; }
-
-[0][x][0-9a-fA-F]+      { unsigned int tmp = 0; sscanf(yytext, "%x", &tmp); *yylval = UINT2NUM(tmp); return TOK_HEX; }
-[0-9]+                  { unsigned int tmp = 0; sscanf(yytext, "%u", &tmp); *yylval = UINT2NUM(tmp); return TOK_UINT; }
-[-][1-9][0-9]*          { int tmp = 0; sscanf(yytext, "%i", &tmp); *yylval = INT2NUM(tmp); return TOK_INT; }
-
-[_a-zA-Z][_a-zA-Z0-9]*[:][_a-zA-Z][_a-zA-Z0-9]* { *yylval = rb_str_new(yytext, yyleng); return TOK_C_NAME; }
-[_a-zA-Z][_a-zA-Z0-9]*      { *yylval = rb_str_new(yytext, yyleng); return TOK_NC_NAME; }
-[\\][_a-zA-Z][_a-zA-Z0-9]*  { *yylval = rb_str_new(yytext, yyleng); return TOK_ESCAPED_NC_NAME; }
-
-.|\n                {}
-
-%%
-
-/* static functions ***************************************************/
-
-static void updateLocation(YYLTYPE *loc, const char *text, int textLen)
-{
-    int i;
-
-    loc->first_line = loc->last_line;
-    loc->first_column = loc->last_column;
-
-    for(i=0; i < textLen; i++){
-
-        if(text[i] == '\n'){
-        
-            loc->last_line++;
-            loc->last_column = 0;
-        }
-        else{
-        
-            loc->last_column++;
-        }
-    }
-}