wabur 0.1.0d2 → 0.2.0d1

data/lib/wab/io/engine.rb

@@ -0,0 +1,118 @@
+
+require 'wab'
+
+module WAB
+
+  module IO
+
+    class Engine
+
+      # Starts the engine by creating a listener on STDIN. Processing threads
+      # are also created to handle the processing of requests.
+      #
+      # tcnt:: processing thread count
+      def initialize(shell, tcnt)
+        @shell = shell
+        @last_rid = 0
+        @pending = {}
+        @lock = Thread::Mutex.new()
+        @queue = Queue.new()
+        tcnt = 1 if 0 >= tcnt
+        @tcnt = tcnt
+      end
+
+      def start()
+        @tcnt.times {
+          Thread.new {
+            process_msg(@queue.pop)
+          }
+        }
+
+        # TBD create timeout thread, sync on lock to check timeout in pending, sleep for .5
+
+        Oj.strict_load($stdin, symbol_keys: true) { |msg|
+          api = msg[:api]
+          if 1 == api
+            @queue.push(msg)
+          elsif 4 == api
+            rid = msg[:rid]
+            call = nil
+            @lock.synchronize {
+              call = @pending.delete(rid)
+            }
+            unless call.nil?
+              call.result = msg[:body]
+              call.thread.run
+            end
+          else
+            # TBD handle error
+          end
+        }
+      end
+
+
+      # Send request to the model portion of the system.
+      #
+      # tql:: the body of the message which should be JSON-TQL as a native Hash
+      def request(tql)
+        call = Call.new() # TBD make timeout seconds a parameter
+        @lock.synchronize {
+          @last_rid += 1
+          call.rid = @last_rid.to_s
+          @pending[call.rid] = call
+        }
+        data = @shell.data({ rid: call.rid, api: 3, body: tql }, true)
+        # Send the message. Make sure to flush to assure it gets sent.
+        $stdout.puts(data.json())
+        $stdout.flush()
+        
+        # Wait for either the response to arrive or for a timeout. In both
+        # cases #run should be called on the thread.
+        Thread.stop
+        call.result
+      end
+
+      def process_msg(native)
+        rid = native[:rid]
+        api = native[:api]
+        body = native[:body]
+        reply = @shell.data({rid: rid, api: 2})
+        if body.nil?
+          reply.set('body.code', -1)
+          reply.set('body.error', 'No body in request.')
+        else
+          data = @shell.data(body, false)
+          data.detect()
+          controller = @shell.controller(data)
+          if controller.nil?
+            reply.set('body.code', -1)
+            reply.set('body.error', 'No handler found.')
+          else
+            op = body[:op]
+            begin
+              if 'NEW' == op && controller.respond_to?(:create)
+                reply.set('body', controller.create(body[:path], body[:query], data.get(:content)))
+              elsif 'GET' == op && controller.respond_to?(:read)
+                reply.set('body', controller.read(body[:path], body[:query]))
+              elsif 'DEL' == op && controller.respond_to?(:delete)
+                reply.set('body', controller.delete(body[:path], body[:query]))
+              elsif 'MOD' == op && controller.respond_to?(:update)
+                # Also used for TQL queries
+                reply.set('body', controller.update(body[:path], body[:query], data.get(:content)))
+              else
+                reply.set('body', controller.handle(data))
+              end
+            rescue Exception => e
+              reply.set('body.code', -1)
+              reply.set('body.error', e.message)
+              reply.set('body.backtrace', e.backtrace)
+            end
+          end
+        end
+        $stdout.puts(reply.json)
+        $stdout.flush
+      end
+
+    end # Engine
+  end # IO
+end # WAB

data/lib/wab/io/shell.rb

@@ -0,0 +1,141 @@
+
+require 'time'
+require 'wab'
+
+module WAB
+
+  module IO
+
+    # A Shell that uses STDIN and STDOUT for all interactions with the View
+    # and Model. Since the View and Model APIs are asynchronous and Controller
+    # calls are synchronous for simplicity some effort is required to block
+    # where needed to achieve the difference in behavior.
+    class Shell < ::WAB::Shell
+
+      attr_reader :path_pos
+      attr_reader :type_key
+      
+      # Sets up the shell with the designated number of processing threads and
+      # the type_key.
+      #
+      # tcnt:: processing thread count
+      # type_key:: key to use for the record type
+      def initialize(tcnt, type_key='kind', path_pos=0)
+        super(type_key, path_pos)
+        @engine = Engine.new(self, tcnt)
+      end
+
+      # Starts listening and processing.
+      def start()
+        @engine.start()
+      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)
+        ::WAB::Impl::Data.new(value, repair)
+      end
+      
+      ### View related methods.
+
+      # Push changed data to the view if it matches one of the subscription
+      # filters.
+      #
+      # data: Wab::Data to push to the view if subscribed
+      def changed(data)
+        raise NotImplementedError.new
+      end
+
+      # Reply asynchronously to a view request.
+      #
+      # rid:: request identifier the reply is associated with
+      # data:: content of the reply to be sent to the view
+      def reply(rid, data)
+        raise NotImplementedError.new
+      end
+
+      ### Model related methods.
+
+      # Returns a WAB::Data that matches the object reference or nil if there
+      # is no match.
+      #
+      # ref:: object reference
+      def get(ref)
+        tql = { where: ref.to_i, select: '$' }
+        result = @engine.request(tql)
+        if result.nil? || 0 != result[:code]
+          if result.nil?
+            raise ::WAB::Error.new("nil result get of #{ref}.")
+          else
+            raise ::WAB::Error.new("error on get of #{ref}. #{result[:error]}")
+          end
+        end
+        result[:results]
+      end
+
+      # Evaluates the JSON TQL query. The TQL should be native Ruby objects
+      # that correspond to the TQL JSON format but using Symbol keys instead
+      # of strings.
+      #
+      # If a +handler+ is provided the call is evaluated asynchronously and
+      # the handler is called with the result of the query. If a +handler+ is
+      # supplied the +tql+ must contain an +:rid+ element that is unique
+      # across all handlers.
+      #
+      # tql:: query to evaluate
+      # handler:: callback handler that implements the #on_result() method
+      def query(tql, handler=nil)
+
+        # TBD handle async, maybe just send and leave it at that
+
+        @engine.request(tql)
+      end
+
+      # Subscribe to changes in stored data and push changes to the controller
+      # if it passes the supplied filter.
+      #
+      # The +controller#changed+ method is called when changes in data cause
+      # the associated object to pass the provided filter.
+      #
+      # controller:: the controller to notify of changed
+      # filter:: the filter to apply to the data. Syntax is that TQL uses for the FILTER clause.
+      def subscribe(controller, filter)
+        raise NotImplementedError.new
+      end
+
+      private
+      
+      def form_where_eq(key, value)
+        value_class = value.class
+        x = ['EQ', key.to_s]
+        if value.is_a?(String)
+          x << "'" + value
+        elsif Time == value_class
+          x << value.utc.iso8601(9)
+        elsif value.nil? ||
+            TrueClass == value_class ||
+            FalseClass == value_class ||
+            Integer == value_class ||
+            Float == value_class ||
+            String == value_class
+          x << value
+        elsif 2 == RbConfig::CONFIG['MAJOR'] && 4 > RbConfig::CONFIG['MINOR'] && Fixnum == value_class
+          x << value
+        else
+          x << value.to_s
+        end
+        x
+      end
+
+    end # Shell
+  end # IO
+end # WAB

data/lib/wab/io.rb

@@ -0,0 +1,13 @@
+
+require 'wab'
+
+module WAB
+  module IO
+  end
+end
+
+require 'wab/io/shell'
+require 'wab/io/engine'
+require 'wab/io/call'
+
+

data/lib/wab/shell.rb

@@ -1,28 +1,34 @@
 module WAB
 
   # The Shell is a duck-typed class. Any shell alternative should implement
-  # all the methods defined in the class except the +initialize+ method. This
-  # class is also the default Ruby version of the shell that can be used for
-  # development and small systems.
+  # all the methods defined in the class except the +initialize+ method.  The
+  # Shell acts as the conduit between the View and Model portions of the MVC
+  # design pattern.
+  #
+  # As the View conduit the Shell usually makes calls to the controller. The
+  # exception to this control flow direction is when data changes and is
+  # pushed out to the view.
+  # 
+  # As the Model, the Shell must respond to request to update the store using
+  # either the CRUD type operations that match the controller.
+  #
+  # Note that this class implementes some basic features related to controller
+  # management but those features can be implemented in other ways as long as
+  # the methods remain the same.
   class Shell
 
-    # Sets up the shell with a view, model, and type_key.
-    def initialize(view, model, type_key='kind')
-      @view = view
-      @model = model
+    # Sets up the shell with a type_key and path position.
+    #
+    # type_key:: key for the type associated with a record
+    # path_pos:: position in a URL path that is the class or type
+    def initialize(type_key='kind', path_pos=0)
       @controllers = {}
       @type_key = type_key
+      @path_pos = path_pos
     end
 
-    # Returns the view instance that can be used for pushing data to a view.
-    def view()
-      @view
-    end
-
-    # Returns the model instance that can be used to get and modify data in
-    # the data store.
-    def model()
-      @model
+    # Starts the shell.
+    def start()
     end
 
     # Returns the path where a data type is located. The default is 'kind'.
@@ -42,6 +48,22 @@ module WAB
       @controllers[type] = controller
     end
 
+    # Returns the controller associated with the type key found in the
+    # data. If a controller has not be registered under that key the default
+    # controller is returned if there is one.
+    #
+    # data:: data to extract the type from for lookup in the controllers
+    def controller(data)
+      path = data.get(:path)
+      if path.nil? || @path_pos <= path.length
+        content = data.get(:content)
+        if content.is_a?(::WAB::Data)
+          @controllers[content.get(@type_key)] || @controllers[nil]
+        end
+      end
+      @controllers[nil]
+    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,
@@ -57,5 +79,60 @@ module WAB
       raise NotImplementedError.new
     end
 
+    ### View related methods.
+
+    # Push changed data to the view if it matches one of the subscription
+    # filters.
+    #
+    # data: Wab::Data to push to the view if subscribed
+    def changed(data)
+      raise NotImplementedError.new
+    end
+
+    # Reply asynchronously to a view request.
+    #
+    # rid:: request identifier the reply is associated with
+    # data:: content of the reply to be sent to the view
+    def reply(rid, data)
+      raise NotImplementedError.new
+    end
+
+    ### Model related methods.
+
+    # Returns a WAB::Data that matches the object reference or nil if there
+    # is no match.
+    #
+    # ref:: object reference
+    def get(ref)
+      raise NotImplementedError.new
+    end
+
+    # Evaluates the JSON TQL query. The TQL should be native Ruby objects
+    # that correspond to the TQL JSON format but using Symbol keys instead
+    # of strings.
+    #
+    # If a +handler+ is provided the call is evaluated asynchronously and
+    # the handler is called with the result of the query. If a +handler+ is
+    # supplied the +tql+ must contain an +:rid+ element that is unique
+    # across all handlers.
+    #
+    # tql:: query to evaluate
+    # handler:: callback handler that implements the #on_result() method
+    def query(tql, handler=nil)
+      raise NotImplementedError.new
+    end
+
+    # Subscribe to changes in stored data and push changes to the controller
+    # if it passes the supplied filter.
+    #
+    # The +controller#changed+ method is called when changes in data cause
+    # the associated object to pass the provided filter.
+    #
+    # controller:: the controller to notify of changed
+    # filter:: the filter to apply to the data. Syntax is that TQL uses for the FILTER clause.
+    def subscribe(controller, filter)
+      raise NotImplementedError.new
+    end
+
   end # Shell
 end # WAB

data/lib/wab/version.rb

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

data/lib/wab.rb

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

data/test/data_test.rb

@@ -1,10 +1,8 @@
 #!/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')
+$: << __dir__
+$: << File.join(File.dirname(File.expand_path(__dir__)), 'lib')
 
 require 'minitest'
 require 'minitest/autorun'
@@ -12,7 +10,7 @@ require 'minitest/autorun'
 require 'wab'
 require 'wab/impl'
 
-$shell = ::WAB::Impl::Shell.new(nil, nil) if $shell.nil?
+$shell = ::WAB::Impl::Shell.new() if $shell.nil?
 
 class DataTest < Minitest::Test
 
@@ -39,20 +37,21 @@ class DataTest < Minitest::Test
                       a: [],
                       h: {},
                     })
+    # 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",
+  "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))
+|, d.json(2).downcase)
   end
 
   def test_validate_keys

data/test/impl_test.rb

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