wabur 0.2.0d1 → 0.4.0d1

data/lib/wab/impl/model.rb

@@ -0,0 +1,197 @@
+
+require 'fileutils'
+require 'oj'
+
+module WAB
+  module Impl
+
+    # The Model class is used to store data when using the
+    # WAB::Impl::Shell. It is no intended for any other use. The *get* and
+    # *query* methods are the primary means of interacting with the model.
+    #
+    # The Model is simple in that it stores data in a Hash references by *ref*
+    # numbers. Data is stores in a directory as separate JSON files that are
+    # named as the *ref* number as a 16 character hexidecimal.
+    class Model
+
+      # Create a new Model using the designated directory as the store.
+      #
+      # dir:: directory to store data in
+      def initialize(dir)
+        @dir = dir.nil? ? nil : File.expand_path(dir)
+        @cnt = 0
+        @map = {}
+        @lock = Thread::Mutex.new
+        FileUtils.mkdir_p(@dir) unless @dir.nil? || Dir.exist?(@dir)
+        load_files unless @dir.nil?
+      end
+
+      # Get a single record in the database. A WAB::Impl::Data object is
+      # returned if not nil.
+      #
+      # ref:: references number of the object to retrieve.
+      def get(ref)
+        @map[ref]
+      end
+
+      # Execute a TQL query.
+      #
+      # _Note that the current implementation does not support nested data
+      # retrieval.
+      #
+      # tql:: query to execute
+      def query(tql)
+        rid = tql[:rid]
+        where = nil
+        filter = nil
+        if tql.has_key?(:where)
+          w = tql[:where]
+          where = w.is_a?(Array) ? ExprParser.parse(w) : w
+        end
+        filter = ExprParser.parse(tql[:filter]) if tql.has_key?(:filter)
+
+        if tql.has_key?(:insert)
+          insert(tql[:insert], rid, where, filter)
+        elsif tql.has_key?(:update)
+          update(tql[:update], rid, where, filter)
+        elsif tql.has_key?(:delete)
+          delete(tql[:delete], rid, where, filter)
+        else
+          select(tql[:select], rid, where, filter)
+        end
+      end
+
+      private
+
+      def insert(obj, rid, where, filter)
+        ref = nil
+        @lock.synchronize {
+          unless where.nil?
+            @map.each_value { |v|
+              if where.eval(v) && (filter.nil? || filter.eval(v))
+                result = { code: -1, error: 'Already exists.' }
+                result[:rid] = rid unless rid.nil?
+                return result
+              end
+            }
+          end
+          @cnt += 1
+          ref = @cnt
+          @map[ref] = Data.new(obj, true)
+          write_to_file(ref, obj)
+        }
+        result = { code: 0, ref: ref }
+        result[:rid] = rid unless rid.nil?
+        result
+      end
+
+      def extract_matches(format, ref, rid, obj)
+        if format.nil?
+          { id: ref, data: obj.native }
+        else
+          format_obj(format, ref, rid, obj)
+        end
+      end
+
+      def select(format, rid, where, filter)
+        matches = []
+        @lock.synchronize {
+          if where.nil? && filter.nil?
+            @map.each { |ref,obj|
+              matches << extract_matches(format, ref, rid, obj)
+            }
+          else
+            @map.each { |ref,obj|
+              if where.eval(obj) && (filter.nil? || filter.eval(obj))
+                matches << extract_matches(format, ref, rid, obj)
+              end
+            }
+          end
+        }
+        result = { code: 0, results: matches }
+        result[:rid] = rid unless rid.nil?
+        result
+      end
+
+      def update(obj, _rid, where, _filter)
+        updated = []
+        @lock.synchronize {
+          if where.is_a?(Expr)
+            # TBD must be able to update portions of an object
+          else
+            # A reference.
+            @map[where] = Data.new(obj, true)
+            updated << where
+            write_to_file(where, obj)
+          end
+        }
+        { code: 0, updated: updated }
+      end
+
+      def delete(_del_opt, _rid, where, filter)
+        deleted = []
+        @lock.synchronize {
+          if where.is_a?(Expr)
+            @map.each { |ref,obj|
+              if where.eval(obj) && (filter.nil? || filter.eval(obj))
+                deleted << ref
+                @map.delete(ref)
+              end
+            }
+          # A reference.
+          elsif !@map.delete(where).nil?
+            deleted << where
+            remove_file(where)
+          end
+        }
+        { code: 0, deleted: deleted }
+      end
+
+      def format_obj(format, ref, rid, obj)
+        case format
+        when Hash
+          native = {}
+          format.each { |k,v| native[k] = format_obj(v, ref, rid, obj) }
+          native
+        when Array
+          format.map { |v| format_obj(v, ref, rid, obj) }
+        when String
+          if '$ref' == format
+            ref
+          elsif '$rid' == format
+            rid
+          elsif '$' == format || '$root' == format
+            obj.native
+          elsif !format.empty? && format.start_with?("'")
+            format[1..-1]
+          else
+            obj.get(format)
+          end
+        else
+          format
+        end
+      end
+
+      def load_files()
+        Dir.foreach(@dir) { |fn|
+          next if '.' == fn[0]
+          ref = fn[0..-6]
+          iref = ref.to_i(16)
+          @cnt = iref if @cnt < iref
+          @map[iref] = Data.new(Oj.load_file(File.join(@dir, fn), mode: :wab), true)
+        }
+      end
+
+      def write_to_file(ref, obj)
+        return if @dir.nil?
+        obj.native if obj.is_a?(WAB::Data)
+        File.open(File.join(@dir, "%016x.json" % ref), 'wb') { |f| f.write(Oj.dump(obj, mode: :wab, indent: 0)) }
+      end
+
+      def remove_file(ref)
+        File.delete(File.join(@dir, "%016x.json" % ref)) unless @dir.nil?
+      end
+
+    end # Model
+  end # Impl
+end # WAB

data/lib/wab/impl/path_expr.rb

@@ -0,0 +1,14 @@
+
+module WAB
+  module Impl
+
+    class PathExpr < Expr
+
+      def initialize(path)
+        super()
+        @path = path
+      end
+
+    end # PathExpr
+  end # Impl
+end # WAB

data/lib/wab/impl/shell.rb

@@ -1,16 +1,101 @@
 
-require 'wab'
+require 'wab/impl/handler'
+require 'wab/impl/model'
 
 module WAB
-
   module Impl
 
     # The shell for reference Ruby implementation.
-    class Shell < ::WAB::Shell
+    class Shell
+      include WAB::ShellLogger
+      extend Forwardable
+
+      # Returns the path where a data type is located. The default is 'kind'.
+      attr_reader :type_key
+      attr_reader :path_pos
+
+      # Call the Model instance with these methods.
+      def_delegators :@model, :get, :query
+
+      # Sets up the shell with the supplied configuration data.
+      #
+      # config:: Configuration object
+      def initialize(config)
+        @pre_path      = config[:path_prefix] || '/v1'
+        @path_pos     = @pre_path.split('/').length - 1
+        base          = config[:base] || '.'
+        @model        = Model.new((config['store.dir'] || File.join(base, 'data')).gsub('$BASE', base))
+        @type_key     = config[:type_key] || 'kind'
+        @logger       = config[:logger]
+        @logger.level = config[:verbosity] unless @logger.nil?
+        @http_dir     = (config['http.dir'] || File.join(base, 'pages')).gsub('$BASE', base)
+        @http_port    = (config['http.port'] || 6363).to_i
+        @controllers  = {}
+
+        requires      = config[:require]
+        case requires
+        when Array
+          requires.each { |r| require r.strip }
+        when String
+          requires.split(',').each { |r| require r.strip }
+        end
+
+        if config[:handler].is_a?(Array)
+          config[:handler].each { |hh| register_controller(hh[:type], hh[:handler]) }
+        end
+      end
+
+      # Start listening. This should be called after registering Controllers
+      # with the Shell.
+      def start()
+        server = WEBrick::HTTPServer.new(Port: @http_port, DocumentRoot: @http_dir)
+        server.mount(@pre_path, WAB::Impl::Handler, self)
+
+        trap 'INT' do server.shutdown end
+        server.start
+      end
 
-      # Sets up the shell with a view, model, and type_key.
-      def initialize(type_key='kind', path_pos=0)
-        super
+      # Register a controller for a named type.
+      #
+      # If a request is received for an unregistered type the default controller
+      # will be used. The default controller is registered with a +nil+ key.
+      #
+      # type:: type name
+      # controller:: Controller instance for handling requests for the
+      #              identified +type+. This can be a Controller, a Controller
+      #              class, or a Controller class name.
+      def register_controller(type, controller)
+        case controller
+        when String
+          controller = Object.const_get(controller).new(self)
+        when Class
+          controller = controller.new(self)
+        end
+        controller.shell = self
+        @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)
+        path = path.native if path.is_a?(WAB::Data)
+        return path_controller(path) unless path.nil? || (path.length <= @path_pos)
+
+        content = data.get(:content)
+        return @controllers[content.get(@type_key)] || @controllers[nil] unless content.nil?
+
+        @controllers[nil]
+      end
+
+      # Returns the controller according to the type in the path.
+      #
+      # path: path Array such as from a URL
+      def path_controller(path)
+        @controllers[path[@path_pos]] || @controllers[nil]
       end
 
       # Create and return a new data instance with the provided initial value.
@@ -27,7 +112,7 @@ module WAB
       def data(value={}, repair=false)
         Data.new(value, repair)
       end
-      
+
     end # Shell
   end # Impl
 end # WAB

data/lib/wab/impl/utils.rb

@@ -0,0 +1,110 @@
+
+module WAB
+  module Impl
+    module Utils
+
+      class << self
+
+        # Convert a key to an +Integer+ or raise.
+        def key_to_int(key)
+          return key if key.is_a?(Integer)
+
+          key = key.to_s if key.is_a?(Symbol)
+          if key.is_a?(String)
+            i = key.to_i
+            return i if i.to_s == key
+          end
+          return key if WAB::Utils.pre_24_fixnum?(key)
+
+          raise WAB::Error, 'path key must be an integer for an Array.'
+        end
+
+        # Returns either an +Integer+ or +nil+.
+        def attempt_key_to_int(key)
+          return key if key.is_a?(Integer)
+
+          key = key.to_s if key.is_a?(Symbol)
+          if key.is_a?(String)
+            i = key.to_i
+            return i if i.to_s == key
+          end
+          return key if WAB::Utils.pre_24_fixnum?(key)
+          nil
+        end
+
+        # Gets the Data element or value identified by the path where the path
+        # elements are separated by the '.' character.
+        def get_node(root, path)
+          return root[path] if path.is_a?(Symbol)
+
+          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
+              return nil if i.zero? && key != i && key != i.to_s
+              node = node[i]
+            else
+              return nil
+            end
+          }
+
+          node
+        end
+
+        # Sets the node value identified by the path where the path elements are
+        # separated by the '.' character.
+        def set_value(node, path, value)
+          path = path.to_s.split('.') unless path.is_a?(Array)
+
+          path[0..-2].each_index { |i|
+            key = path[i]
+            if node.is_a?(Hash)
+              key = key.to_sym
+              unless node.has_key?(key)
+                node[key] = attempt_key_to_int(path[i + 1]).nil? ? {} : []
+              end
+              node = node[key]
+            elsif node.is_a?(Array)
+              key = key_to_int(key)
+              if key < node.length && -node.length < key
+                node = node[key]
+              else
+                entry = attempt_key_to_int(path[i + 1]).nil? ? {} : []
+                if key < -node.length
+                  node.unshift(entry)
+                else
+                  node[key] = entry
+                end
+                node = entry
+              end
+            else
+              raise WAB::TypeError, "Can not set a member of an #{node.class}."
+            end
+          }
+
+          key = path[-1]
+
+          if node.is_a?(Hash)
+            node[key.to_sym] = value
+          elsif node.is_a?(Array)
+            key = key_to_int(key)
+            if key < -node.length
+              node.unshift(value)
+            else
+              node[key] = value
+            end
+          else
+            raise WAB::TypeError, "Can not set a member of an #{node.class}."
+          end
+          value
+        end
+
+      end # Singleton class
+
+    end # Utils
+  end # Impl
+end # WAB

data/lib/wab/impl.rb

@@ -7,5 +7,29 @@ module WAB
   end
 end
 
+require 'wab/impl/configuration'
 require 'wab/impl/data'
+require 'wab/impl/expr'
+require 'wab/impl/path_expr'
+require 'wab/impl/bool_expr'
 require 'wab/impl/shell'
+require 'wab/impl/utils'
+
+# Require the concrete Expr subclasses so a mapping table can be created for
+# the parser.
+
+require 'wab/impl/exprs/between'
+require 'wab/impl/exprs/eq'
+require 'wab/impl/exprs/gt'
+require 'wab/impl/exprs/gte'
+require 'wab/impl/exprs/has'
+require 'wab/impl/exprs/in'
+require 'wab/impl/exprs/lt'
+require 'wab/impl/exprs/lte'
+require 'wab/impl/exprs/regex'
+
+require 'wab/impl/exprs/and'
+require 'wab/impl/exprs/or'
+require 'wab/impl/exprs/not'
+
+require 'wab/impl/expr_parser'

data/lib/wab/io/call.rb

@@ -1,21 +1,18 @@
 
-require 'wab'
-
 module WAB
-
   module IO
 
     class Call
 
-      attr_accessor :rid
       attr_accessor :result
       attr_accessor :thread
+      attr_accessor :rid
+      attr_accessor :giveup
 
       def initialize(timeout=2.0)
-        @rid = nil
-        @result = nil
-        @thread = Thread.current
+        @rid = rid
         @giveup = Time.now + timeout
+        @thread = Thread.current
       end
 
     end # Call