wabur 0.1.0d1 → 0.1.0d2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f881d414a328e743c262513bde6977d3a28a3ec3
-  data.tar.gz: f3d99084f2ad9ccb619ceb3572a4c0bc66863c5f
+  metadata.gz: f4ae2c00f65bf680b3432bd10ec6135aeed7e6bc
+  data.tar.gz: 01f5f822d40665b8f314d3744ccdcf7bf35c071c
 SHA512:
-  metadata.gz: 0b4ca9f500c474908d6a4b740a86ec360f0386332e7d55bd724743124d041983c1854834cbac66a874c73b2a7f1b3c674224c830a4d0b3dee3f50204efe89b3f
-  data.tar.gz: b71155371f81f098034483486ff036e36ccaee5c460072dc61a7fe3012df97de643c2eea5514c9561f50ace56c5b1685cbde4cd04e3a322d5dd490ce15f71f1a
+  metadata.gz: 48320600e036669b67ba89b0b241440891af68ca7f59c287e632a96e3df1512cc1b917c0bb8425d9d4e7040d4c145ccb5ed28d0d3f62b228aceecc40e58f3ad2
+  data.tar.gz: 7f83da64ecc5ed24f2bc2e225204f757873fda7f2843634bae74afb7be3dcf497098aa3d2754aa2be7f8ade8535b3096e25b3a7c9429723ead367cc1ed42bcd9

data/README.md

@@ -1,5 +1,7 @@
 # WABuR (Web Application Builder using Ruby)
 
+[![Build Status](https://img.shields.io/travis/ohler55/wabur/develop.svg)](http://travis-ci.org/ohler55/wabur?branch=develop) ![Gem](https://img.shields.io/gem/v/wabur.svg) ![Gem](https://img.shields.io/gem/dt/wabur.svg)
+
 Ruby is a great language but for performance C is a better alternative. It is
 possible to get the best of both as evident with [Oj](http://www.ohler.com/oj)
 and [Ox](http://www.ohler.com/ox). C by itself allowed
@@ -43,16 +45,28 @@ C shell that handles HTTP and data storage.
 
 [Continue reading ...](pages/Architecture.md)
 
-## Participate
+## Participate and Contribute
 
 If you like the idea and want to help out or become a core developer on the
 project send me an [email](mailto:peter@ohler.com). Get in on the ground floor
 and lets make something awesome together.
 
+### Guidelines
+
+These are the simple guidelines for contrinuting.
+
+1. Coordinate with me first before getting started to avoid duplication of
+   effort or implementing something in conflict with the plans.
+
+2. Branch off the develop branch and submit a PR.
+
+3. Write unit tests.
+
+4. Write straight forward, clean, and simple code. No magic stuff, no monkey
+   patching Ruby core classes, and no inheriting from core classes.
+
 ## Planning
 
 The plan is informal and high level until more details are defined.
 
 [Details ...](pages/Plan.md)
-
-  

data/lib/wab/data.rb

@@ -1,4 +1,6 @@
 
+require 'uri'
+
 module WAB
 
   # The class representing the cananical data structure in WAB. Typically the
@@ -7,21 +9,12 @@ module WAB
   # class (has the same methods and behavior).
   class Data
 
-    # This method is included only for testing purposes of the Ruby base
-    # Shell. It should only be called by the Shell. Create a new Data instance
-    # with the initial value provided. The value must be a Hash or Array. The
-    # members of the Hash or Array must be nil, boolean, String, Integer,
-    # Float, BigDecimal, Array, Hash, Time, WAB::UUID, or WAB::IRI.
-    def initialize(value=nil)
-      # TBD
-    end
-
     # Gets the Data element or value identified by the path where the path
     # elements are separated by the '.' character. The path can also be a
     # array of path node identifiers. For example, child.grandchild is the
     # same as ['child', 'grandchild'].
     def get(path)
-      # TBD
+      raise NotImplementedError.new
     end
     
     # Sets the node value identified by the path where the path elements are
@@ -29,44 +22,80 @@ module WAB
     # node identifiers. For example, child.grandchild is the same as ['child',
     # 'grandchild']. The value must be one of the allowed data values
     # described in the initialize method.
+    #
+    # For arrays, the behavior is similar to an Array#[] with the exception
+    # of a negative index less than the negative length in which case the
+    # value is prepended (Array#unshift).
+    #
+    # path:: path to location to be set
+    # value:: value to set
+    # repair:: flag indicating invalid value should be repaired if possible
     def set(path, value)
-      # TBD
+      raise NotImplementedError.new
     end
 
     # Each child of the Data instance is provided as an argument to a block
     # when the each method is called.
     def each()
-      # TBD
+      raise NotImplementedError.new
     end
 
     # Each leaf of the Data instance is provided as an argument to a block
     # when the each method is called. A leaf is a primitive that has no
     # children and will be nil, a Boolean, String, Numberic, Time, WAB::UUID,
-    # or WAB::IRI.
+    # or URI.
     def each_leaf()
-      # TBD
+      raise NotImplementedError.new
     end
 
     # Make a deep copy of the Data instance.
     def clone()
-      # TBD
+      raise NotImplementedError.new
     end
 
     # Returns the instance converted to native Ruby values such as a Hash,
     # Array, etc.
     def native()
-      # TBD
+      raise NotImplementedError.new
     end
 
     # Returns true if self and other are either the same or have the same
     # contents. This is a deep comparison.
     def eql?(other)
-      # TBD
+      raise NotImplementedError.new
+    end
+
+    # Returns the length of the root element.
+    def length()
+      raise NotImplementedError.new
+    end
+
+    # Returns the number of leaves in the data tree.
+    def leaf_count()
+      raise NotImplementedError.new
+    end
+
+    # Returns the number of nodes in the data tree.
+    def size()
+      raise NotImplementedError.new
     end
 
     # Encode the data as a JSON string.
     def json(indent=0)
-      # TBD
+      raise NotImplementedError.new
+    end
+
+    private
+
+    # This method is included only to raise an error if an attempt is made to
+    # create an instance directly.  The Shell implementation should provide a
+    # similar initializer which should create a new Data instance with the
+    # initial value provided. The value must be a Hash or Array. The members
+    # of the Hash or Array must be nil, boolean, String, Integer, Float,
+    # BigDecimal, Array, Hash, Time, URI::HTTP, or WAB::UUID. Keys to Hashes
+    # must be Symbols.
+    def initialize(value=nil, repair=false)
+      raise NotImplementedError.new
     end
 
   end # Data

data/lib/wab/impl/data.rb

@@ -0,0 +1,371 @@
+
+require 'uri'
+require 'oj'
+
+module WAB
+  module Impl
+
+    # The class representing the cananical data structure in WAB. Typically
+    # the Data instances are factory created by the Shell and will most likely
+    # not be instance of this class but rather a class that is a duck-type of
+    # this class (has the same methods and behavior).
+    class Data < ::WAB::Data
+
+      # This method should not be called directly. New instances should be
+      # created by using a Shell#data method.
+      #
+      # Creates a new Data instance with the initial value provided. The value
+      # must be a Hash or Array. The members of the Hash or Array must be nil,
+      # boolean, String, Integer, Float, BigDecimal, Array, Hash, Time,
+      # WAB::UUID, or the Ruby URI::HTTP.
+      #
+      # value:: initial value
+      # repair:: flag indicating invalid value should be repaired if possible
+      def initialize(value, repair)
+        if repair
+          value = fix(value)
+        else
+          validate(value)
+        end
+        @root = value
+      end
+
+      # Gets the Data element or value identified by the path where the path
+      # elements are separated by the '.' character. The path can also be a
+      # array of path node identifiers. For example, child.grandchild is the
+      # same as ['child', 'grandchild'].
+      def get(path)
+        path = path.to_s.split('.') unless path.is_a?(Array)
+        node = @root
+        path.each { |key|
+          if node.is_a?(Hash)
+            node = node[key.to_sym]
+          elsif node.is_a?(Array)
+            i = key.to_i
+            if 0 == i && '0' != key && 0 != key
+              node = nil
+              break
+            end
+            node = node[i]
+          else
+            node = nil
+            break
+          end
+        }
+        node
+      end
+      
+      # Sets the node value identified by the path where the path elements are
+      # separated by the '.' character. The path can also be a array of path
+      # node identifiers. For example, child.grandchild is the same as ['child',
+      # 'grandchild']. The value must be one of the allowed data values
+      # described in the initialize method.
+      #
+      # For arrays, the behavior is similar to an Array#[] with the exception
+      # of a negative index less than the negative length in which case the
+      # value is prepended (Array#unshift).
+      #
+      # path:: path to location to be set
+      # value:: value to set
+      # repair:: flag indicating invalid value should be repaired if possible
+      def set(path, value, repair=false)
+        raise StandardError.new("path can not be empty.") if path.empty?
+        if repair
+          value = fix_value(value)
+        else
+          validate_value(value)
+        end
+        node = @root
+        path = path.to_s.split('.') unless path.is_a?(Array)
+        path[0..-2].each { |key|
+          if node.is_a?(Hash)
+            key = key.to_sym
+            node[key] = {} unless node.has_key?(key)
+            node = node[key]
+          elsif node.is_a?(Array)
+            i = key.to_i
+            raise StandardError.new("path key must be an integer for an Array.") if (0 == i && '0' != key && 0 != key)
+            if i < node.length && -node.length < i
+              node = node[i]
+            else
+              # TBD if next key is a number then make an array instead
+              nn = {}
+              if i < -node.length
+                node.unshift(nn)
+              else
+                node[i] = nn
+              end
+              node = nn
+            end
+          else
+            raise StandardError.new("Can not set a member of an #{node.class}.")
+          end
+        }
+        key = path[-1]
+        if node.is_a?(Hash)
+          key = key.to_sym
+          node[key] = value
+        elsif node.is_a?(Array)
+          i = key.to_i
+          raise StandardError.new("path key must be an integer for an Array.") if (0 == i && '0' != key && 0 != key)
+          if i < -node.length
+            node.unshift(value)
+          else
+            node[i] = value
+          end
+        else
+          raise StandardError.new("Can not set a member of an #{node.class}.")
+        end
+        value
+      end
+
+      # Each child of the Data instance is provided as an argument to a block
+      # when the each method is called.
+      def each(&block)
+        each_node([], @root, block)
+      end
+
+      # Each leaf of the Data instance is provided as an argument to a block
+      # when the each method is called. A leaf is a primitive that has no
+      # children and will be nil, a Boolean, String, Numberic, Time, WAB::UUID,
+      # or URI.
+      def each_leaf(&block)
+        each_leaf_node([], @root, block)
+      end
+
+      # Make a deep copy of the Data instance.
+      def clone()
+        # avoid validation by using a empty Hash for the intial value.
+        c = self.class.new({}, false)
+        c.instance_variable_set(:@root, clone_value(@root))
+        c
+      end
+
+      # Returns the instance converted to native Ruby values such as a Hash,
+      # Array, etc.
+      def native()
+        @root
+      end
+
+      # Returns true if self and other are either the same or have the same
+      # contents. This is a deep comparison.
+      def eql?(other)
+        # Any object that is of a class derived from the API class is a
+        # candidate for being ==.
+        return false unless other.is_a?(::WAB::Data)
+        values_eql?(@root, other.native)
+      end
+      alias == eql?
+      
+      # Returns the length of the root element.
+      def length()
+        @root.length
+      end
+
+      # Returns the number of leaves in the data tree.
+      def leaf_count()
+        branch_count(@root)
+      end
+
+      # Returns the number of nodes in the data tree.
+      def size()
+        branch_size(@root)
+      end
+
+      # Encode the data as a JSON string.
+      def json(indent=0)
+        Oj.dump(@root, mode: :wab, indent: indent)
+      end
+
+      private
+
+      # Raise an exception if the value is not a suitable data element. If the
+      # repair flag is true an attempt is made to fix the value if possible by
+      # replacing non-symbol keys with Symbols and converting unsupported
+      # objects with a to_h or a to_s.
+      #
+      # value:: value to validate
+      def validate(value)
+        if value.is_a?(Hash)
+          value.each_pair { |k, v| 
+            raise StandardError.new("Hash keys must be Symbols.") unless k.is_a?(Symbol)
+            validate_value(v)
+          }
+        elsif value.is_a?(Array)
+          value.each { |v|
+            validate_value(v)
+          }
+        else
+          raise StandardError.new("Data values must be either a Hash or an Array")
+        end
+        value
+      end
+
+      def validate_value(value)
+        value_class = value.class
+        if value.nil? ||
+            TrueClass == value_class ||
+            FalseClass == value_class ||
+            Integer == value_class ||
+            Float == value_class ||
+            String == value_class ||
+            Time == value_class ||
+            BigDecimal == value_class ||
+            URI::HTTP == value_class ||
+            ::WAB::UUID == value_class
+          # valid values
+        elsif Hash == value_class
+          value.each_pair { |k, v| 
+            raise StandardError.new("Hash keys must be Symbols.") unless k.is_a?(Symbol)
+            validate_value(v)
+          }
+        elsif Array == value_class
+          value.each { |v|
+            validate_value(v)
+          }
+        else
+          raise StandardError.new("#{value_class.to_s} is not a valid Data value.")
+        end
+        value
+      end
+
+      # Fix values by returing either the value or the fixed alternative. In
+      # the cases of Hash and Array a copy is always made. (its just easier)
+      def fix(value)
+        if value.is_a?(Hash)
+          old = value
+          value = {}
+          old.each_pair { |k, v|
+            k = k.to_sym unless k.is_a?(Symbol)
+            value[k] = fix_value(v)
+          }
+        elsif value.is_a?(Array)
+          old = value
+          value = []
+          old.each { |v|
+            value << fix_value(v)
+          }
+        elsif value.respond_to?(:to_h) && 0 == value.method(:to_h).arity
+          value = value.to_h
+          raise StandardError.new("Data values must be either a Hash or an Array") unless value.is_a?(Hash)
+          value = fix(value)
+        else
+          raise StandardError.new("Data values must be either a Hash or an Array")
+        end
+        value
+      end
+
+      def fix_value(value)
+        value_class = value.class
+        if value.nil? ||
+            TrueClass == value_class ||
+            FalseClass == value_class ||
+            Integer == value_class ||
+            Float == value_class ||
+            String == value_class ||
+            Time == value_class ||
+            BigDecimal == value_class ||
+            URI::HTTP == value_class ||
+            ::WAB::UUID == value_class
+          # valid values
+        elsif Hash == value_class
+          old = value
+          value = {}
+          old.each_pair { |k, v|
+            k = k.to_sym unless k.is_a?(Symbol)
+            value[k] = fix_value(v)
+          }
+        elsif Array == value_class
+          old = value
+          value = []
+          old.each { |v|
+            value << fix_value(v)
+          }
+        elsif value.respond_to?(:to_h) && 0 == value.method(:to_h).arity
+          value = value.to_h
+          raise StandardError.new("Data values must be either a Hash or an Array") unless value.is_a?(Hash)
+          value = fix(value)
+        elsif value.respond_to?(:to_s)
+          value = value.to_s
+          raise StandardError.new("Data values must be either a Hash or an Array") unless value.is_a?(String)
+        else
+          raise StandardError.new("#{value_class.to_s} is not a valid Data value.")
+        end
+        value
+      end
+
+      def each_node(path, value, block)
+        block.call(path, value)
+        if value.is_a?(Hash)
+          value.each_pair { |k, v| each_node(path + [k], v, block) }
+        elsif value.is_a?(Array)
+          value.each_index { |i| each_node(path + [i], value[i], block) }
+        end
+      end
+
+      def each_leaf_node(path, value, block)
+        if value.is_a?(Hash)
+          value.each_pair { |k, v| each_leaf_node(path + [k], v, block) }
+        elsif value.is_a?(Array)
+          value.each_index { |i| each_leaf_node(path + [i], value[i], block) }
+        else
+          block.call(path, value)
+        end
+      end
+
+      def branch_count(value)
+        cnt = 0
+        if value.is_a?(Hash)
+          value.each_value { |v| cnt += branch_count(v) }
+        elsif value.is_a?(Array)
+          value.each { |v| cnt += branch_count(v) }
+        else
+          cnt = 1
+        end
+        cnt
+      end
+
+      def branch_size(value)
+        cnt = 1
+        if value.is_a?(Hash)
+          value.each_value { |v| cnt += branch_size(v) }
+        elsif value.is_a?(Array)
+          value.each { |v| cnt += branch_size(v) }
+        end
+        cnt
+      end
+
+      def values_eql?(v0, v1)
+        return false unless v0.class == v1.class
+        if v0.is_a?(Hash)
+          return false unless v0.length == v1.length
+          v0.each_key { |k|
+            return false unless values_eql?(v0[k], v1[k])
+            return false unless v1.has_key?(k)
+          }
+        elsif v0.is_a?(Array)
+          return false unless v0.length == v1.length
+          v0.each_index { |i|
+            return false unless values_eql?(v0[i], v1[i])
+          }
+        else
+          v0 == v1
+        end
+      end
+
+      def clone_value(value)
+        if value.is_a?(Hash)
+          c = {}
+          value.each_pair { |k, v| c[k] = clone_value(v) }
+        elsif value.is_a?(Array)
+          c = []
+          value.each { |v| c << clone_value(v) }
+        else
+          c = value.clone
+        end
+        c
+      end
+
+    end # Data
+  end # Impl
+end # WAB

data/lib/wab/impl/shell.rb

@@ -0,0 +1,33 @@
+
+require 'wab'
+
+module WAB
+
+  module Impl
+
+    # The shell for reference Ruby implementation.
+    class Shell < ::WAB::Shell
+
+      # Sets up the shell with a view, model, and type_key.
+      def initialize(view, model, type_key='kind')
+        super
+      end
+
+      # Create and return a new data instance with the provided initial value.
+      # The value must be a Hash or Array. The members of the Hash or Array
+      # must be nil, boolean, String, Integer, Float, BigDecimal, Array, Hash,
+      # Time, URI::HTTP, or WAB::UUID. Keys to Hashes must be Symbols.
+      #
+      # If the repair flag is true then an attempt will be made to fix the
+      # value by replacing String keys with Symbols and calling to_h or to_s
+      # on unsupported Objects.
+      #
+      # value:: initial value
+      # repair:: flag indicating invalid value should be repaired if possible
+      def data(value={}, repair=false)
+        Data.new(value, repair)
+      end
+      
+    end # Shell
+  end # Impl
+end # WAB

data/lib/wab/impl.rb

@@ -0,0 +1,11 @@
+
+require 'wab'
+
+module WAB
+  # Web Application Builder implementation of the WAB APIs.
+  module Impl
+  end
+end
+
+require 'wab/impl/data'
+require 'wab/impl/shell'

data/lib/wab/shell.rb

@@ -42,5 +42,20 @@ module WAB
       @controllers[type] = controller
     end
 
+    # Create and return a new data instance with the provided initial value.
+    # The value must be a Hash or Array. The members of the Hash or Array must
+    # be nil, boolean, String, Integer, Float, BigDecimal, Array, Hash, Time,
+    # URI::HTTP, or WAB::UUID. Keys to Hashes must be Symbols.
+    #
+    # If the repair flag is true then an attempt will be made to fix the value
+    # by replacing String keys with Symbols and calling to_h or to_s on
+    # unsupported Objects.
+    #
+    # value:: initial value
+    # repair:: flag indicating invalid value should be repaired if possible
+    def data(value=nil, repair=false)
+      raise NotImplementedError.new
+    end
+
   end # Shell
 end # WAB

data/lib/wab/uuid.rb

@@ -0,0 +1,28 @@
+
+module WAB
+
+  # The UUID class representing a 128 bit UUID although values are not
+  # validated for conformane to the ISO/IEC specifications.
+  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?
+    end
+
+    # Returns the string representation of the UUID.
+    def to_s
+      @id
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && @id == other.id
+    end
+
+  end # UUID
+end # WAB

data/lib/wab/version.rb

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

data/lib/wab.rb

@@ -3,3 +3,8 @@
 module WAB
 end
 
+require 'wab/data'
+require 'wab/model'
+require 'wab/shell'
+require 'wab/uuid'
+require 'wab/version'

data/pages/Plan.md

@@ -1,11 +1,21 @@
 # Plan
 
-More details will be added here as progress continues. For now the hight level plan is:
+More details will be added here as progress continues. For now the high level plan is:
+
+- _Define APIs - initial complete_
+
+- 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
+
+- Extern Glue implemenation and test
+ - this is in the WAB module
 
-- Define APIs
-  - View API
-  - Model/Store API
 - Structure Ruby Framework
-  - Embedded Glue layer
-  - External Glue layer
+ - Embedded Glue layer
+ - External Glue layer
   

data/test/data_test.rb

@@ -0,0 +1,254 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+$: << File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'lib')
+$: << File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'oj', 'ext')
+$: << File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'oj', 'lib')
+
+require 'minitest'
+require 'minitest/autorun'
+
+require 'wab'
+require 'wab/impl'
+
+$shell = ::WAB::Impl::Shell.new(nil, nil) if $shell.nil?
+
+class DataTest < Minitest::Test
+
+  class ToHash
+    def initialize(x, y)
+      @h = {x: x, y: y }
+    end
+    def to_h
+      @h
+    end
+  end
+
+  def test_json
+    d = $shell.data({
+                      boo: true,
+                      n: nil,
+                      num: 7,
+                      float: 7.654,
+                      str: 'a string',
+                      t: Time.gm(2017, 1, 5, 15, 4, 33.123456789),
+                      big: BigDecimal('63.21'),
+                      uri: URI('http://opo.technology/sample'),
+                      uuid: ::WAB::UUID.new('b0ca922d-372e-41f4-8fea-47d880188ba3'),
+                      a: [],
+                      h: {},
+                    })
+    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))
+  end
+
+  def test_validate_keys
+    assert_raises() { d = $shell.data({ 'a' => 1}) }
+  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_hash_length
+    d = $shell.data({a: 1, b: 2})
+    assert_equal(2, d.length())
+  end
+
+  def test_array_length
+    d = $shell.data(['a', 'b', 'c'])
+    assert_equal(3, d.length())
+  end
+
+  def test_mixed_length
+    d = $shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    assert_equal(2, d.length())
+  end
+
+  def test_empty_leaf_count
+    d = $shell.data()
+    assert_equal(0, d.leaf_count())
+  end
+
+  def test_hash_leaf_count
+    d = $shell.data({a: 1, b: 2, c:{}})
+    assert_equal(2, d.leaf_count())
+  end
+
+  def test_array_leaf_count
+    d = $shell.data(['a', 'b', 'c', []])
+    assert_equal(3, d.leaf_count())
+  end
+
+  def test_mixed_leaf_count
+    d = $shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    assert_equal(4, d.leaf_count())
+  end
+
+  def test_empty_size
+    d = $shell.data()
+    assert_equal(1, d.size())
+  end
+
+  def test_hash_size
+    d = $shell.data({a: 1, b: 2, c:{}})
+    assert_equal(4, d.size())
+  end
+
+  def test_array_size
+    d = $shell.data(['a', 'b', 'c', []])
+    assert_equal(5, d.size())
+  end
+
+  def test_mixed_size
+    d = $shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    assert_equal(7, d.size())
+  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 == d2, "same keys and values should be eql")
+    assert(!(d == d3), "same values different keys should not be eql")
+    assert(!(d == d4), "same keys different values should not be eql")
+  end
+
+  def test_clone
+    d = $shell.data({a: 1, b: ['a', 'b', { c: 3}]})
+    c = d.clone
+    assert(d == c)
+  end
+
+end # DataTest

data/test/impl_test.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+$: << File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'lib')
+
+require 'minitest'
+require 'minitest/autorun'
+
+require 'wab/impl'
+
+$shell = ::WAB::Impl::Shell.new(nil, nil)
+
+require 'data_test'

metadata

@@ -1,15 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: wabur
 version: !ruby/object:Gem::Version
-  version: 0.1.0d1
+  version: 0.1.0d2
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-03 00:00:00.000000000 Z
-dependencies: []
+date: 2017-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
 description: 'Web Application Builder '
 email: peter@ohler.com
 executables: []
@@ -17,21 +73,27 @@ extensions: []
 extra_rdoc_files:
 - README.md
 - pages/Architecture.md
-- pages/Goals.md
 - pages/Plan.md
+- pages/Goals.md
 files:
 - LICENSE
 - README.md
 - lib/wab.rb
 - lib/wab/controller.rb
 - lib/wab/data.rb
+- lib/wab/impl.rb
+- lib/wab/impl/data.rb
+- lib/wab/impl/shell.rb
 - lib/wab/model.rb
 - lib/wab/shell.rb
+- lib/wab/uuid.rb
 - lib/wab/version.rb
 - lib/wab/view.rb
 - pages/Architecture.md
 - pages/Goals.md
 - pages/Plan.md
+- test/data_test.rb
+- test/impl_test.rb
 homepage: http://github.com/ohler55/wabur
 licenses:
 - MIT
@@ -61,4 +123,6 @@ rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Web Application Builder
-test_files: []
+test_files:
+- test/impl_test.rb
+- test/data_test.rb