wabur 0.2.0d1 → 0.4.0d1

data/lib/wab/uuid.rb

@@ -6,19 +6,16 @@ module WAB
   class UUID
 
     attr_reader :id
-    
+
     # Initializes a UUID from string representation of the UUID
     # following the pattern "123e4567-e89b-12d3-a456-426655440000".
     def initialize(id)
       @id = id.downcase
-      # TBD change to WAB exception
-      raise Exception.new("Invalid UUID format.") if /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.match(@id).nil?
+      raise WAB::ParseError.new('Invalid UUID format.') unless WAB::Utils.uuid_format?(@id)
     end
 
     # Returns the string representation of the UUID.
-    def to_s
-      @id
-    end
+    alias to_s id
 
     def ==(other)
       other.is_a?(self.class) && @id == other.id

data/lib/wab/version.rb

@@ -1,5 +1,5 @@
 
 module WAB
-  # Current version of the module. 
-  VERSION = '0.2.0d1'
+  # Current version of the module.
+  VERSION = '0.4.0d1'
 end

data/lib/wab.rb

@@ -6,6 +6,9 @@ end
 require 'wab/controller'
 require 'wab/data'
 require 'wab/errors'
+require 'wab/open_controller'
 require 'wab/shell'
+require 'wab/shell_logger'
+require 'wab/utils'
 require 'wab/uuid'
 require 'wab/version'

data/pages/Plan.md

@@ -2,20 +2,26 @@
 
 More details will be added here as progress continues. For now the high level plan is:
 
-- _Define APIs - initial complete_
+### Completed
 
-- Start the WAB::Dev module
- - WAB::Dev::Data class
- - WAB::Dev::UUID class
- - WAB::Dev::Model class
- - WAB::Dev::Shell class
- - WAB::Dev::View class
- - WAB::Dev::Controller class
+- _Define APIs - initial complete_
+- _WAB::IO::Shell - complete_
+- _stdio sample - complete_
 
-- Extern Glue implemenation and test
- - this is in the WAB module
+### Pending
 
-- Structure Ruby Framework
- - Embedded Glue layer
- - External Glue layer
-  
+- Benchmarks - started
+  - Overall as a black box
+  - WAB::IO::Shell alone
+- Spec driven Javascript libraries
+  - Define spec format
+  - implement and test generic Javascript app
+- Ruby Runner
+  - Runner framework
+  - HTTP server
+  - Model
+    - In memory object management
+    - Data store
+- Embedded Ruby Runner (separate project)
+- End to end examples
+- Advanced Javascript displays

data/test/bench_io_shell.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+require 'benchmark'
+
+require 'wab/impl'
+require 'wab/io'
+require 'mirror_controller'
+
+# Windows does not support fork
+Process.exit(-1) if RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+
+to_r, to_w = IO.pipe
+from_r, from_w = IO.pipe
+
+if fork.nil? # child
+  $stdin = to_r
+  to_w.close
+  $stdout = from_w
+  from_r.close
+
+  shell = WAB::IO::Shell.new(1, 'kind', 0)
+  shell.timeout = 0.5
+  shell.logger.level = Logger::WARN # change to Logger::INFO for debugging
+  shell.register_controller(nil, MirrorController.new(shell))
+  shell.start
+
+  Process.exit(0)
+else
+  to_r.close
+  from_w.close
+
+  # Using simple timing to make it easier to report results.
+  n = 10000
+  reply = nil
+  start = Time.now
+  n.times { |i|
+    to_w.puts(WAB::Impl::Data.new({rid: 'rid-read-id', api: 1, body: {op: 'GET', path: ['sample', '12345']}}, false).json)
+    to_w.flush
+    Oj.strict_load(from_r, symbol_keys: true) { |msg| reply = msg; break }
+    to_w.puts(WAB::Impl::Data.new({rid: "#{i+1}", api: 4, body: {code: 0, results:[{kind: 'sample', id: 12345, num: 7}]}}, false).json)
+    to_w.flush
+    Oj.strict_load(from_r, symbol_keys: true) { |msg| reply = msg; break }
+  }
+  dt = Time.now - start
+  puts "#{n} simulated GETs in #{dt} seconds. #{(dt * 1000000.0 /n).to_i} usecs/GET or #{(n / dt).to_i} GETs/sec"
+end

data/test/{impl_test.rb → helper.rb}

@@ -1,11 +1,9 @@
-#!/usr/bin/env ruby
 # encoding: UTF-8
 
-$: << __dir__
+$LOAD_PATH << __dir__
+$LOAD_PATH << File.expand_path('../lib', __dir__)
 
 require 'minitest'
 require 'minitest/autorun'
 
 require 'wab/impl'
-
-require 'data_test'

data/test/mirror_controller.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require 'wab'
+require 'wab/impl'
+
+class MirrorController < WAB::OpenController
+  def initialize(shell)
+    super(shell)
+  end
+
+  def handle(data)
+    data
+  end
+
+end # MirrorController

data/test/test_configuration.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+class TestConfiguration < TestImpl
+  def setup
+    usage_string = 'Test Banner'
+    options_map = {
+      environment: {
+        val:   'test',
+        type:  String,
+        doc:   'Configure the environment for this session',
+        short: '-e',
+        arg:   'ENV',
+      }
+    }
+    @config = WAB::Impl::Configuration.new(usage_string, options_map)
+  end
+
+  def test_initialization
+    assert_equal({:environment=>"test"}, @config.map )
+  end
+
+  def test_parse_config_file
+    expected = {
+      :store   => { :dir => "$BASE/test/store/data" },
+      :handler => [{ :type =>"Article" }],
+      :http    => { :dir => "$BASE/view/test-pages" }
+    }
+    assert_equal(expected,
+      @config.parse_config_file(File.expand_path('samples/test-config.conf', __dir__))
+    )
+    assert_equal(expected,
+      @config.parse_config_file(File.expand_path('samples/test-config.json', __dir__))
+    )
+    assert_raises(LoadError) {
+      @config.parse_config_file(File.expand_path('samples/test-config.yml', __dir__))
+    }
+  end
+end # TestConfiguration

data/test/test_data.rb

@@ -0,0 +1,207 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+require 'wab'
+require 'wab/impl'
+
+class TestImplData < TestImpl
+
+  class ToHash
+    def initialize(x, y)
+      @h = {x: x, y: y }
+    end
+
+    def to_h
+      @h
+    end
+  end
+
+  def test_json
+    d = make_sample_data
+    # downcase to match Ruby 2.3 and 2.4 which encode BigDecimal differently.
+    assert_equal(%|{
+  "boo":true,
+  "n":null,
+  "num":7,
+  "float":7.654,
+  "str":"a string",
+  "t":"2017-01-05t15:04:33.123456789z",
+  "big":0.6321e2,
+  "uri":"http://opo.technology/sample",
+  "uuid":"b0ca922d-372e-41f4-8fea-47d880188ba3",
+  "a":[],
+  "h":{}
+}
+|, d.json(2).downcase)
+  end
+
+  def test_validate_keys
+    assert_raises(WAB::KeyError) { d = @shell.data({ 'a' => 1}) }
+    assert_raises(WAB::TypeError) { d = @shell.data('text') }
+  end
+
+  def test_repair_keys
+    d = @shell.data({ 'a' => 1}, true)
+    assert_equal({a:1}, d.native, 'data not repaired')
+  end
+
+  def test_validate_non_hash_array
+    assert_raises { d = @shell.data(123) }
+  end
+
+  def test_fix_non_hash_array
+    # can not fix this one
+    assert_raises { d = @shell.data(123, true) }
+  end
+
+  def test_validate_object
+    assert_raises { d = @shell.data({a: 1..3}) }
+  end
+
+  def test_repair_to_s_object
+    d = @shell.data({a: 1..3}, true)
+    assert_equal({a:'1..3'}, d.native, 'data not repaired')
+  end
+
+  def test_repair_to_h_object
+    d = @shell.data(ToHash.new(1, 2), true)
+    assert_equal({x:1,y:2}, d.native, 'data not repaired')
+  end
+
+  def test_hash_get
+    d = @shell.data({a: 1, b: 2})
+    assert_equal(2, d.get('b'), "failed to get 'b'")
+    assert_equal(2, d.get([:b]), 'failed to get [:b]')
+    assert_equal(1, d.get(['a']), "failed to get ['a']")
+    assert_nil(d.get(['d']), "failed to get ['d']")
+  end
+
+  def test_array_get
+    d = @shell.data(['a', 'b', 'c'])
+    assert_equal('b', d.get('1'), "failed to get '1'")
+    assert_equal('c', d.get(['2']), "failed to get ['2']")
+    assert_equal('b', d.get([1]), 'failed to get [1]')
+    assert_equal('a', d.get([0]), 'failed to get [0]')
+    assert_equal('c', d.get([-1]), 'failed to get [-1]')
+    assert_nil(d.get([4]), 'failed to get [4]')
+  end
+
+  def test_get_mixed
+    d = @shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    assert_equal(3, d.get('b.2.c'), "failed to get 'b.2.c'")
+    assert_equal(3, d.get([:b, 2, 'c']), 'failed to get [b, 2, c]')
+  end
+
+  def test_hash_set
+    d = @shell.data({a: 1})
+    d.set('b', 2)
+    d.set([:c], 3)
+    d.set([:d], 1..4, true)
+    assert_raises { d.set([:e], 1..5) }
+    assert_equal(%|{
+  "a":1,
+  "b":2,
+  "c":3,
+  "d":"1..4"
+}
+|, d.json(2))
+    # replace existing
+    d.set([:c], -3)
+    assert_equal(%|{
+  "a":1,
+  "b":2,
+  "c":-3,
+  "d":"1..4"
+}
+|, d.json(2))
+  end
+
+  def test_array_set
+    d = @shell.data(['x'])
+    d.set([2], 'd')
+    assert_equal(%|["x",null,"d"]|, d.json, 'after d')
+    d.set([1], 'c')
+    assert_equal(%|["x","c","d"]|, d.json, 'after c')
+    d.set([0], 'y')
+    assert_equal(%|["y","c","d"]|, d.json, 'after y')
+    d.set([-3], 'b')
+    assert_equal(%|["b","c","d"]|, d.json, 'after b')
+    d.set([-4], 'a')
+    assert_equal(%|["a","b","c","d"]|, d.json, 'after a')
+  end
+
+  def test_set_mixed
+    d = @shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    d.set('b.2', 'c')
+    assert_equal(%|{"a":1,"b":["a","b","c"]}|, d.json)
+  end
+
+  def test_each
+    d = @shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    paths = []
+    values = []
+    d.each { |p, v|
+      paths << p
+      values << v
+    }
+    assert_equal([[], [:a], [:b], [:b, 0], [:b, 1], [:b, 2], [:b, 2, :c]], paths, 'paths mismatch')
+    assert_equal([{:a=>1, :b=>['a', 'b', {:c=>3}]}, 1, ['a', 'b', {:c=>3}], 'a', 'b', {:c=>3}, 3], values, 'values mismatch')
+  end
+
+  def test_each_leaf
+    d = @shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    paths = []
+    values = []
+    d.each_leaf { |p, v|
+      paths << p
+      values << v
+    }
+    assert_equal([[:a], [:b, 0], [:b, 1], [:b, 2, :c]], paths, 'paths mismatch')
+    assert_equal([1, 'a', 'b', 3], values, 'values mismatch')
+  end
+
+  def test_eql
+    d = @shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    d2 = @shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    d3 = @shell.data({a: 1, b: ['a', 'b', { d: 3}]})
+    d4 = @shell.data({a: 1, b: ['a', 'b', { c: 4}]})
+
+    assert(d.native == d2.native, 'same keys and values should be eql')
+    assert(!(d.native == d3.native), 'same values different keys should not be eql')
+    assert(!(d.native == d4.native), 'same keys different values should not be eql')
+  end
+
+  def test_deep_dup
+    d = @shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    c = d.deep_dup
+    assert(d.native == c.native)
+  end
+
+  def test_detect
+    d = @shell.data({
+                      t: '2017-01-05T15:04:33.123456789Z',
+                      uris: ['http://opo.technology/sample'],
+                      sub:{
+                        uuid: 'b0ca922d-372e-41f4-8fea-47d880188ba3'
+                      }
+                    })
+    d.detect
+    assert_equal(%|{
+  "t":"2017-01-05t15:04:33.123456789z",
+  "uris":[
+    "http://opo.technology/sample"
+  ],
+  "sub":{
+    "uuid":"b0ca922d-372e-41f4-8fea-47d880188ba3"
+  }
+}
+|, d.json(2).downcase)
+
+    assert_equal(Time, d.get('t').class)
+    assert_equal(::URI::HTTP, d.get('uris.0').class)
+    assert_equal(WAB::UUID, d.get('sub.uuid').class)
+  end
+
+end # TestImplData

data/test/test_expr.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+require 'wab/impl/expr_parser'
+
+require 'test_expr_between'
+require 'test_expr_eq'
+require 'test_expr_gt'
+require 'test_expr_gte'
+require 'test_expr_has'
+require 'test_expr_in'
+require 'test_expr_lt'
+require 'test_expr_lte'
+require 'test_expr_regex'
+
+require 'test_expr_not'
+require 'test_expr_and'
+require 'test_expr_or'
+
+class TestExpr < TestImpl
+
+  def test_expr_parser_parse
+    natives = [
+               ['EQ', 'num', 7],
+               ['AND', ['HAS', 'str'], ['EQ', 'num', 7]],
+              ]
+    natives.each { |n|
+      x = WAB::Impl::ExprParser.parse(n)
+      assert_equal(n, x.native, "parsed failed for #{n}")
+    }
+  end
+
+end # TestExpr

data/test/test_expr_and.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprAnd < TestImpl
+
+  def test_and_native
+    x = WAB::Impl::And.new(WAB::Impl::Has.new('num'), WAB::Impl::Eq.new('num', 7))
+    assert_equal(['AND', ['HAS', 'num'], ['EQ', 'num', 7]], x.native, 'AND native mismatch')
+  end
+
+  def test_and
+    d = make_sample_data
+    x = WAB::Impl::And.new(WAB::Impl::Has.new('num'), WAB::Impl::Eq.new('num', 7))
+    assert(x.eval(d), 'checking AND match')
+
+    x = WAB::Impl::And.new(WAB::Impl::Has.new('num'), WAB::Impl::Eq.new('num', 8))
+    refute(x.eval(d), 'checking AND mismatch')
+  end
+
+  # TBD tests with no args, with one, with more than 2, test using append_arg
+
+end # TestExprAnd

data/test/test_expr_between.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprBetween < TestImpl
+
+  def test_between_native
+    x = WAB::Impl::Between.new('num', 3, 7, true, false)
+    assert_equal(['BETWEEN', 'num', 3, 7, true, false], x.native, 'BETWEEN native mismatch')
+  end
+
+  def test_between_int
+    d = make_sample_data
+    x = WAB::Impl::Between.new('num', 7, 10)
+    assert(x.eval(d), 'checking BETWEEN match with an integer arg')
+
+    x = WAB::Impl::Between.new('num', 8, 10)
+    refute(x.eval(d), 'checking BETWEEN mismatch with an integer arg')
+
+    x = WAB::Impl::Between.new('num', 5, 7)
+    assert(x.eval(d), 'checking BETWEEN match with an integer arg')
+
+    x = WAB::Impl::Between.new('num', 5, 6)
+    refute(x.eval(d), 'checking BETWEEN mismatch with an integer arg')
+
+    # exclusive of min
+    x = WAB::Impl::Between.new('num', 6, 10, false)
+    assert(x.eval(d), 'checking BETWEEN match with an integer arg')
+
+    x = WAB::Impl::Between.new('num', 7, 10, false)
+    refute(x.eval(d), 'checking BETWEEN mismatch with an integer arg')
+
+    x = WAB::Impl::Between.new('num', 5, 8, false, false)
+    assert(x.eval(d), 'checking BETWEEN match with an integer arg')
+
+    x = WAB::Impl::Between.new('num', 5, 7, false, false)
+    refute(x.eval(d), 'checking BETWEEN mismatch with an integer arg')
+  end
+
+  # TBD more tests for each type, Float, boolean, String, URI, UUID, Time, BigDecimal, nil
+
+end # TestExprBetween

data/test/test_expr_eq.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprEq < TestImpl
+
+  def test_eq_native
+    x = WAB::Impl::Eq.new('num', 7)
+    assert_equal(['EQ', 'num', 7], x.native, 'EQ native mismatch')
+  end
+
+  def test_eq_int
+    d = make_sample_data
+    x = WAB::Impl::Eq.new('num', 7)
+    assert(x.eval(d), 'checking EQ match with an integer arg')
+
+    x = WAB::Impl::Eq.new('num', 17)
+    refute(x.eval(d), 'checking EQ mismatch with an integer arg')
+  end
+
+  # TBD more tests for each type, Float, boolean, String, URI, UUID, Time, BigDecimal, nil
+
+end # TestExprEq

data/test/test_expr_gt.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprGt < TestImpl
+
+  def test_gt_native
+    x = WAB::Impl::Gt.new('num', 3)
+    assert_equal(['GT', 'num', 3], x.native, 'GT native mismatch')
+  end
+
+  def test_gt_int
+    d = make_sample_data
+    x = WAB::Impl::Gt.new('num', 6)
+    assert(x.eval(d), 'checking GT match with an integer arg')
+
+    x = WAB::Impl::Gt.new('num', 7)
+    refute(x.eval(d), 'checking GT mismatch with an integer arg')
+  end
+
+  # TBD more tests for each type, Float, boolean, String, URI, UUID, Time, BigDecimal, nil
+
+end # TestExprGt

data/test/test_expr_gte.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprGte < TestImpl
+
+  def test_gte_native
+    x = WAB::Impl::Gte.new('num', 3)
+    assert_equal(['GTE', 'num', 3], x.native, 'GTE native mismatch')
+  end
+
+  def test_gte_int
+    d = make_sample_data
+    x = WAB::Impl::Gte.new('num', 7)
+    assert(x.eval(d), 'checking GTE match with an integer arg')
+
+    x = WAB::Impl::Gte.new('num', 8)
+    refute(x.eval(d), 'checking GTE mismatch with an integer arg')
+  end
+
+  # TBD more tests for each type, Float, boolean, String, URI, UUID, Time, BigDecimal, nil
+
+end # TestExprGte

data/test/test_expr_has.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprHas < TestImpl
+
+  def test_has_int
+    d = make_sample_data
+    x = WAB::Impl::Has.new('num')
+    assert(x.eval(d), 'checking HAS match')
+
+    x = WAB::Impl::Has.new('none')
+    refute(x.eval(d), 'checking HAS mismatch')
+  end
+
+  # TBD test with path as an array, tests with symbol path
+
+end # TestExprHas

data/test/test_expr_in.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprIn < TestImpl
+
+  def test_in_native
+    x = WAB::Impl::In.new('num', 3, 4, 5)
+    assert_equal(['IN', 'num', 3, 4, 5], x.native, 'IN native mismatch')
+  end
+
+  def test_in_int
+    d = make_sample_data
+    x = WAB::Impl::In.new('num', 1, 3, 5, 7, 11)
+    assert(x.eval(d), 'checking IN match with an integer arg')
+
+    x = WAB::Impl::In.new('num', 0, 2, 4, 6, 8, 10)
+    refute(x.eval(d), 'checking IN mismatch with an integer arg')
+  end
+
+  # TBD more tests for each type, Float, boolean, String, URI, UUID, Time, BigDecimal, nil
+
+end # TestExprIn

data/test/test_expr_lt.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprLt < TestImpl
+
+  def test_lt_native
+    x = WAB::Impl::Lt.new('num', 3)
+    assert_equal(['LT', 'num', 3], x.native, 'LT native mismatch')
+  end
+
+  def test_lt_int
+    d = make_sample_data
+    x = WAB::Impl::Lt.new('num', 8)
+    assert(x.eval(d), 'checking LT match with an integer arg')
+
+    x = WAB::Impl::Lt.new('num', 7)
+    refute(x.eval(d), 'checking LT mismatch with an integer arg')
+  end
+
+  # TBD more tests for each type, Float, boolean, String, URI, UUID, Time, BigDecimal, nil
+
+end # TestExprLt

data/test/test_expr_lte.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative 'helper'
+
+class TestExprLte < TestImpl
+
+  def test_lte_native
+    x = WAB::Impl::Lte.new('num', 3)
+    assert_equal(['LTE', 'num', 3], x.native, 'LTE native mismatch')
+  end
+
+  def test_lte_int
+    d = make_sample_data
+    x = WAB::Impl::Lte.new('num', 7)
+    assert(x.eval(d), 'checking LTE match with an integer arg')
+
+    x = WAB::Impl::Lte.new('num', 6)
+    refute(x.eval(d), 'checking LTE mismatch with an integer arg')
+  end
+
+  # TBD more tests for each type, Float, boolean, String, URI, UUID, Time, BigDecimal, nil
+
+end # TestExprLte