wabur 0.2.0d1 → 0.4.0d1

data/lib/wab/impl/expr_parser.rb

@@ -0,0 +1,55 @@
+
+module WAB
+  module Impl
+    class ExprParser
+      XMAP = {
+        between: Between,
+        eq: Eq,
+        gt: Gt,
+        gte: Gte,
+        in: In,
+        has: Has,
+        lt: Lt,
+        lte: Lte,
+        regex: Regex,
+        and: And,
+        or: Or,
+        not: Not,
+      }.freeze
+
+      class << self
+        # Parses an Array into a set of Expr subsclasses.
+        #
+        # native:: native Ruby representation of the expression.
+        def parse(native)
+          raise WAB::TypeError.new('Invalid expression. Must be an Array.') unless native.is_a?(Array)
+
+          op = native[0]
+          op = op.downcase.to_sym unless op.is_a?(Symbol)
+
+          xclass = XMAP[op]
+          raise WAB::Error.new("#{op} is not a valid expression function.") if xclass.nil?
+
+          args = []
+          native[1..-1].each { |n|
+            args << if n.is_a?(Array)
+                      parse(n)
+                    elsif n.is_a?(String)
+                      unless n.empty?
+                        if "'" == n[0]
+                          n[1..-1]
+                        else
+                          WAB::Impl::Data.detect_string(n)
+                        end
+                      end
+                    else
+                      n
+                    end
+          }
+          xclass.new(*args)
+        end
+      end
+
+    end # ExprParser
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/and.rb

@@ -0,0 +1,29 @@
+
+module WAB
+  module Impl
+
+    # A logical AND expression.
+    class And < BoolExpr
+
+      # Create an AND expression with the provided arguments which must be
+      # instances of subclasses of the Expr class.
+      #
+      # args:: argument to the AND expression
+      def initialize(*args)
+        super
+      end
+
+      def eval(data)
+        @args.each { |a|
+          return false unless a.eval(data)
+        }
+        true
+      end
+
+      def native()
+        @args.map(&:native).unshift('AND')
+      end
+
+    end # And
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/between.rb

@@ -0,0 +1,41 @@
+
+module WAB
+  module Impl
+
+    # Matches numeric nodes between a minimum and maximum value. By default
+    # the matches are inclusive of the minimum and maximum. The optional
+    # arguments allow the inclusivity to be changed to exclusive separately
+    # for the minimum and maximum. By default the min_incl and max_incl are
+    # true. If set to false the corresponding limit becomes exclusive. An
+    # error is returned if used with non-numeric minimum or maximum.
+    class Between < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to compare
+      # min:: minimum
+      # max:: maximum
+      # min_incl:: minimum inclusive flag
+      # max_incl:: maximum inclusive flag
+      def initialize(path, min, max, min_incl=true, max_incl=true)
+        super(path)
+        @min = min
+        @max = max
+        @min_incl = min_incl
+        @max_incl = max_incl
+      end
+
+      def eval(data)
+        value = data.get(@path)
+        return false if (@min_incl ? value < @min : value <= @min)
+        return false if (@max_incl ? @max < value : @max <= value)
+        true
+      end
+
+      def native()
+        ['BETWEEN', @path, @min, @max, @min_incl, @max_incl]
+      end
+
+    end # Between
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/eq.rb

@@ -0,0 +1,28 @@
+
+module WAB
+  module Impl
+
+    # Matches a node that has the same value as provided at the end of the
+    # path provided. Any type is acceptable.#
+    class Eq < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to compare
+      # value:: value to compare against
+      def initialize(path, value)
+        super(path)
+        @value = value
+      end
+
+      def eval(data)
+        data.get(@path) == @value
+      end
+
+      def native()
+        ['EQ', @path, @value]
+      end
+
+    end # Eq
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/gt.rb

@@ -0,0 +1,30 @@
+
+module WAB
+  module Impl
+
+    # Matches a node that has a value greater than the provided value. If a
+    # integer or float is provided then both integer and floats are
+    # checked. If the value provided is a time then only time nodes are
+    # checked. Any other type results in an error.
+    class Gt < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to compare
+      # value:: value to compare against
+      def initialize(path, value)
+        super(path)
+        @value = value
+      end
+
+      def eval(data)
+        data.get(@path) > @value
+      end
+
+      def native()
+        ['GT', @path, @value]
+      end
+
+    end # Gt
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/gte.rb

@@ -0,0 +1,30 @@
+
+module WAB
+  module Impl
+
+    # Matches a node that has a value greater than or equals to the provided
+    # value. If a integer or float is provided then both integer and floats
+    # are checked. If the value provided is a time then only time nodes are
+    # checked. Any other type results in an error.
+    class Gte < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to compare
+      # value:: value to compare against
+      def initialize(path, value)
+        super(path)
+        @value = value
+      end
+
+      def eval(data)
+        data.get(@path) >= @value
+      end
+
+      def native()
+        ['GTE', @path, @value]
+      end
+
+    end # Gte
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/has.rb

@@ -0,0 +1,26 @@
+
+module WAB
+  module Impl
+
+    # Used to filters out all nodes that do not have a node at the end of the
+    # provided path.
+    class Has < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to check
+      def initialize(path)
+        super(path)
+      end
+
+      def eval(data)
+        data.has?(@path)
+      end
+
+      def native()
+        ['HAS', @path]
+      end
+
+    end # Has
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/in.rb

@@ -0,0 +1,28 @@
+
+module WAB
+  module Impl
+
+    # Match any node that has a value equal to one of the values provided in
+    # the argument list after the path. This can be used with any type.
+    class In < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to compare
+      # values:: values to compare to
+      def initialize(path, *values)
+        super(path)
+        @values = values
+      end
+
+      def eval(data)
+        @values.include?(data.get(@path))
+      end
+
+      def native()
+        ['IN', @path].concat(@values)
+      end
+
+    end # In
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/lt.rb

@@ -0,0 +1,30 @@
+
+module WAB
+  module Impl
+
+    # Matches a node that has a value less than the provided value. If a
+    # integer or float is provided then both integer and floats are
+    # checked. If the value provided is a time then only time nodes are
+    # checked. Any other type results in an error.
+    class Lt < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to compare
+      # value:: value to compare against
+      def initialize(path, value)
+        super(path)
+        @value = value
+      end
+
+      def eval(data)
+        data.get(@path) < @value
+      end
+
+      def native()
+        ['LT', @path, @value]
+      end
+
+    end # Lt
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/lte.rb

@@ -0,0 +1,30 @@
+
+module WAB
+  module Impl
+
+    # Matches a node that has a value less than or equal to the provided
+    # value. If a integer or float is provided then both integer and floats
+    # are checked. If the value provided is a time then only time nodes are
+    # checked. Any other type results in an error.
+    class Lte < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to compare
+      # value:: value to compare against
+      def initialize(path, value)
+        super(path)
+        @value = value
+      end
+
+      def eval(data)
+        data.get(@path) <= @value
+      end
+
+      def native()
+        ['LTE', @path, @value]
+      end
+
+    end # Lte
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/not.rb

@@ -0,0 +1,27 @@
+
+module WAB
+  module Impl
+
+    # Negates and expression.
+    class Not < Expr
+
+      # Create an NOT expression with the provided argument which must be an
+      # instance of a subclass of the Expr class.
+      #
+      # arg:: argument to the NOT expression
+      def initialize(arg)
+        super()
+        @arg = arg
+      end
+
+      def eval(data)
+        !@arg.eval(data)
+      end
+
+      def native()
+        ['NOT', @arg.native]
+      end
+
+    end # Not
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/or.rb

@@ -0,0 +1,29 @@
+
+module WAB
+  module Impl
+
+    # A logical OR expression.
+    class Or < BoolExpr
+
+      # Create an OR expression with the provided arguments which must be
+      # instances of subclasses of the Expr class.
+      #
+      # args:: argument to the OR expression
+      def initialize(*args)
+        super
+      end
+
+      def eval(data)
+        @args.each { |a|
+          return true if a.eval(data)
+        }
+        false
+      end
+
+      def native()
+        @args.map(&:native).unshift('OR')
+      end
+
+    end # Or
+  end # Impl
+end # WAB

data/lib/wab/impl/exprs/regex.rb

@@ -0,0 +1,28 @@
+
+module WAB
+  module Impl
+
+    class Regex < PathExpr
+
+      # Creates a new instance with the provided parameters.
+      #
+      # path:: path to the value to compare
+      # rx:: regexp to match against a string value from the path lookup
+      def initialize(path, rx)
+        super(path)
+        @rx = rx.is_a?(Regexp) ? rx : Regexp.new(rx.to_s)
+      end
+
+      def eval(data)
+        value = data.get(@path)
+        return !@rx.match(value).nil? if value.is_a?(String)
+        false
+      end
+
+      def native()
+        ['REGEX', @path, @rx.source]
+      end
+
+    end # Regex
+  end # Impl
+end # WAB

data/lib/wab/impl/handler.rb

@@ -0,0 +1,95 @@
+
+require 'webrick'
+
+module WAB
+  module Impl
+
+    # Handler for requests that fall under the path assigned to the
+    # Controller. This is used only with the WAB::Impl::Shell.
+    class Handler < WEBrick::HTTPServlet::AbstractServlet
+
+      def initialize(server, shell)
+        super(server)
+        @shell = shell
+      end
+
+      def do_GET(req, res)
+        controller, path, query = extract_req(req)
+        log_response('controller.read', path, query) if @shell.logger.info?
+        send_result(controller.read(path, query), res)
+      rescue StandardError => e
+        send_error(e, res)
+      end
+
+      def do_PUT(req, res)
+        controller, path, query, body = extract_req(req)
+        log_response_with_body('controller.create', path, query, body) if @shell.logger.info?
+        send_result(controller.create(path, query, body), res)
+      rescue StandardError => e
+        send_error(e, res)
+      end
+
+      def do_POST(req, res)
+        controller, path, query, body = extract_req(req)
+        log_response_with_body('controller.update', path, query, body) if @shell.logger.info?
+        send_result(controller.update(path, query, body), res)
+      rescue StandardError => e
+        send_error(e, res)
+      end
+
+      def do_DELETE(req, res)
+        controller, path, query = extract_req(req)
+        log_response('controller.delete', path, query) if @shell.logger.info?
+        send_result(controller.delete(path, query), res)
+      rescue StandardError => e
+        send_error(e, res)
+      end
+
+      private
+
+      def log_response(caller, path, query)
+        @shell.logger.info("#{caller}(#{path.join('/')}#{query})")
+      end
+
+      def log_response_with_body(caller, path, query, body)
+        @shell.logger.info("#{caller}(#{path.join('/')}#{query}, #{body.json})")
+      end
+
+      # Pulls and converts the request path, query, and body. Also returns the
+      # controller.
+      def extract_req(req)
+        path = req.path.split('/')[1..-1]
+        query = {}
+        req.query.each { |k,v| query[k.to_sym] = v }
+        if req.body.nil?
+          body = nil
+        else
+          body = Oj.strict_load(req.body, symbol_keys: true)
+          body = Data.new(body, false)
+          body.detect
+        end
+        [@shell.path_controller(path), path, query, body]
+      end
+
+      # Sends the results from a controller request.
+      def send_result(result, res)
+        result = @shell.data(result) unless result.is_a?(WAB::Data)
+        res.status = 200
+        res['Content-Type'] = 'application/json'
+        @shell.logger.debug("Reply: #{result.json}") if @shell.logger.debug?
+        res.body = result.json
+      end
+
+      # Sends an error from a rescued call.
+      def send_error(e, res)
+        res.status = 500
+        res['Content-Type'] = 'application/json'
+        body = { code: -1, error: "#{e.class}: #{e.message}" }
+        body[:backtrace] = e.backtrace
+        res.body = @shell.data(body).json
+        @shell.logger.warn(%|*-*-* #{e.class}: #{e.message}\n      #{e.backtrace.join("\n      ")}|)
+      end
+
+    end # Handler
+  end # Impl
+end # WAB