wabur 0.2.0d1 → 0.4.0d1

data/lib/wab/impl/configuration.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'logger'
+
+module WAB
+  module Impl
+
+    # Handles the configuration for a Shell Implementation and the Ruby Runner
+    class Configuration
+
+      attr_accessor :map
+      
+      def initialize(usage, options)
+        @map = {}
+        opts = OptionParser.new(usage)
+        config_file = nil
+        log_level = Logger::WARN
+        
+        opts.on('-c', '--config PATH', String, 'Configuration file.') { |c| config_file = c }
+        opts.on('-r', '--require LIBRARY', String, 'Require.')        { |r| require r }
+        opts.on('-v', '--verbose', 'Increase verbosity.')             { log_level += 1 }
+        opts.on('-h', '--help', 'Show this display.')                 { puts opts.help; Process.exit!(0) }
+
+        # Process command-line arguments and append them, in order, to an empty hash @map
+        add_options(opts, options)
+
+        opts.parse(ARGV)
+
+        # Move the @map sideways and replace with defaults.
+        command_line_map = @map
+        @map = {}
+        build_default_map(options)
+
+        # If a config file was specified load it and merge into @map.
+        @map = merge_map(@map, parse_config_file(config_file)) unless config_file.nil?
+
+        # Merge in the command line map.
+        @map = merge_map(@map, command_line_map) unless command_line_map.empty?
+      end
+
+      # Walks the options map and calls +opts.on+ for each option so that all
+      # are provided when +--help+ is called.
+      def add_options(opts, options, path='')
+        options.each_pair { |k,v|
+          next unless v.is_a?(Hash)
+          key_path = path.empty? ? k.to_s : "#{path}.#{k}"
+          if v.has_key?(:val)
+            default = v[:val]
+            if default.is_a?(Array)
+              opts.on(v[:short], "--#{key_path} #{v[:arg]}", String, v[:doc]) { |val| arg_append(key_path, val, v[:parse]) }
+            else
+              opts.on(v[:short], "--#{key_path} #{v[:arg]}", v[:type], "#{v[:doc]} Default: #{default}") { |val| set(key_path, val) }
+            end
+          else
+            add_options(opts, v, key_path)
+          end
+        }
+      end
+
+      # Appends an arg to an array in the configuration.
+      def arg_append(path, val, parse)
+        parts = val.split('=')
+        if 1 < parts.length
+          val = {}
+          parse.each_index { |i| val[parse[i].to_sym] = parts[i] }
+        end
+        a = get(path)
+        if a.nil?
+          a = []
+          set(path, a)
+        end
+        a.push(val)
+      end
+
+      # Builds a map from the default options passed in.
+      def build_default_map(options, path='')
+        options.each_pair { |k,v|
+          next unless v.is_a?(Hash)
+          key_path = path.empty? ? k.to_s : "#{path}.#{k}"
+          if v.has_key?(:val)
+            set(key_path, v[:val])
+          else
+            build_default_map(v, key_path)
+          end
+        }
+      end
+
+      # Recursive merge of other into prime.
+      def merge_map(prime, other)
+        prime.merge(other) { |key,prime_value,other_value|
+          case prime_value
+          when Hash
+            merge_map(prime_value, other_value)
+          when Array
+            prime_value + other_value
+          else
+            other_value
+          end
+        }
+      end
+      
+      # Returns a Hash of configuration data.
+      #
+      # TBD: Add validation to ensure only a Hash object is returned
+      def parse_config_file(file)
+        return {} unless File.exist?(file)
+
+        case File.extname(file)
+        when /\.conf$/i
+          parse_conf_file(file)
+        when /\.json$/i
+          Oj.load_file(file, mode: :strict, symbol_keys: true)
+        when /\.ya?ml$/i
+          begin
+            require 'safe_yaml/load'
+            SafeYAML.load_file(file) || {}
+          rescue LoadError
+            # Re-raise with a more descriptive message. This should generally
+            # abort the configuration loading.
+            raise LoadError.new(%{Could not load the requested resource. Please install the 'safe_yaml' gem via
+Bundler or directly, and try loading again.
+})
+          end
+        end
+      end
+
+      # Returns a Hash containing data obtained by parsing a UNIX style conf
+      # file.
+      #
+      # For example, +handler.sample.count = 63+ and +handler.sample.path = /v1+
+      # will be parsed into the following:
+      #
+      #    { handler: { sample: { count: 63, path: "/v1" } } }
+      def parse_conf_file(file)
+        config = {}
+
+        File.open(File.expand_path(file)) do |f|
+          f.each_line do |line|
+            line.strip!
+            next if line.empty? || line.start_with?('#')
+            key, value = line.split('=').map(&:strip)
+            set_map(config, key, value)
+          end
+        end
+        config
+      end
+
+      def set_map(node, path, value)
+        return node if path.empty?
+        Utils.set_value(node, path, value)
+      end
+
+      def set(path, value)
+        set_map(@map, path, value)
+      end
+      alias []= set
+
+      def get(path)
+        Utils.get_node(@map, path)
+      end
+      alias [] get
+
+    end # Configuration
+  end # Impl
+end # WAB

data/lib/wab/impl/data.rb

@@ -1,4 +1,5 @@
 
+require 'date'
 require 'uri'
 require 'oj'
 
@@ -9,7 +10,28 @@ module WAB
     # 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
+    class Data < WAB::Data
+      attr_reader :root
+
+      def self.detect_string(s)
+        if WAB::Utils.uuid_format?(s)
+          WAB::UUID.new(s)
+        elsif WAB::Utils.wab_time_format?(s)
+          begin
+            DateTime.parse(s).to_time
+          rescue
+            s
+          end
+        elsif s.downcase.start_with?('http://')
+          begin
+            URI(s)
+          rescue
+            s
+          end
+        else
+          s
+        end
+      end
 
       # This method should not be called directly. New instances should be
       # created by using a Shell#data method.
@@ -30,36 +52,48 @@ module WAB
         @root = value
       end
 
+      # Returns the instance converted to native Ruby values such as a Hash,
+      # Array, etc.
+      alias native root
+
+      # Returns true if the Data element or value identified by the path
+      # exists 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 has?(path)
+        return (@root.is_a?(Hash) && @root.has_key?(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)
+            key = key.to_sym
+            return false unless node.has_key?(key)
+            node = node[key]
+          elsif node.is_a?(Array)
+            i = key.to_i
+            return false if 0 == i && '0' != key && 0 != key
+            len = node.length
+            return false unless -len <= i && i < len
+            node = node[i]
+          else
+            return false
+          end
+        }
+        true
+      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)
-        if path.is_a?(Symbol)
-          node = @root[path] 
-        else
-          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
-          }
-        end
-        return Data.new(node, false, false) if node.is_a?(Hash) || node.is_a?(Array)
-        node
+        node = Utils.get_node(@root, path)
+
+        return node unless node.is_a?(Hash) || node.is_a?(Array)
+        Data.new(node, false, false)
       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',
@@ -74,8 +108,8 @@ module WAB
       # 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 value.is_a?(::WAB::Data)
+        raise WAB::Error, 'path can not be empty.' if path.empty?
+        if value.is_a?(WAB::Data)
           value = value.native
         elsif repair
           value = fix_value(value)
@@ -83,47 +117,7 @@ module WAB
           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
+        Utils.set_value(node, path, value)
       end
 
       # Each child of the Data instance is provided as an argument to a block
@@ -141,44 +135,13 @@ module WAB
       end
 
       # Make a deep copy of the Data instance.
-      def clone()
+      def deep_dup()
         # 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.instance_variable_set(:@root, deep_dup_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)
@@ -189,7 +152,8 @@ module WAB
       # UUID:: "b0ca922d-372e-41f4-8fea-47d880188ba3"
       # URI:: "http://opo.technology/sample", HTTP only
       def detect()
-        # TBD
+        return detect_hash(@root) if @root.is_a?(Hash)
+        detect_array(@root) if @root.is_a?(Array)
       end
 
       private
@@ -202,117 +166,96 @@ module WAB
       # 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)
-          }
+          validate_hash(value)
         elsif value.is_a?(Array)
-          value.each { |v|
-            validate_value(v)
-          }
+          value.each { |v| validate_value(v) }
         else
-          raise StandardError.new("Data values must be either a Hash or an Array")
+          raise WAB::TypeError
         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)
-          }
-        elsif '2' == RbConfig::CONFIG['MAJOR'] && '4' > RbConfig::CONFIG['MINOR'] && Fixnum == value_class
-          # valid value
+        return value if valid_class(value)
+        if value.is_a?(Hash)
+          validate_hash(value)
+        elsif value.is_a?(Array)
+          value.each { |v| validate_value(v) }
         else
-          raise StandardError.new("#{value_class.to_s} is not a valid Data value.")
+          raise WAB::TypeError, "#{value_class} 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 validate_hash(hsh)
+        hsh.each_pair { |k, v|
+          raise WAB::KeyError unless k.is_a?(Symbol)
+          validate_value(v)
+        }
+      end
+
+      def valid_class(value)
+        value_class = value.class
+        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 ||
+          WAB::Utils.pre_24_fixnum?(value)
+      end
+
+      # Fix values by returing either the value or the fixed alternative.
       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)
-          }
+        value_class = value.class
+        if Hash == value_class
+          value = fix_hash(value)
+        elsif Array == value_class
+          value = value.map { |v| 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)
+          raise WAB::TypeError unless value.is_a?(Hash)
           value = fix(value)
         else
-          raise StandardError.new("Data values must be either a Hash or an Array")
+          raise WAB::TypeError
         end
         value
       end
 
       def fix_value(value)
+        return value if valid_class(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)
-          }
+        if Hash == value_class
+          value = fix_hash(value)
         elsif Array == value_class
-          old = value
-          value = []
-          old.each { |v|
-            value << fix_value(v)
-          }
-        elsif '2' == RbConfig::CONFIG['MAJOR'] && '4' > RbConfig::CONFIG['MINOR'] && Fixnum == value_class
-          # valid value
+          value = value.map { |v| 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)
+          raise WAB::TypeError 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)
+          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.")
+          raise WAB::TypeError, "#{value_class} is not a valid Data value."
         end
         value
       end
 
+      def fix_hash(hsh)
+        old = hsh
+        hsh = {}
+        old.each_pair { |k, v|
+          k = k.to_sym unless k.is_a?(Symbol)
+          hsh[k] = fix_value(v)
+        }
+        hsh
+      end
+
       def each_node(path, value, block)
         block.call(path, value)
         if value.is_a?(Hash)
@@ -332,69 +275,49 @@ module WAB
         end
       end
 
-      def branch_count(value)
-        cnt = 0
+      def deep_dup_value(value)
         if value.is_a?(Hash)
-          value.each_value { |v| cnt += branch_count(v) }
+          c = {}
+          value.each_pair { |k, v| c[k] = deep_dup_value(v) }
         elsif value.is_a?(Array)
-          value.each { |v| cnt += branch_count(v) }
+          c = value.map { |v| deep_dup_value(v) }
         else
-          cnt = 1
+          value_class = value.class
+          c = if value.nil? ||
+                  TrueClass  == value_class ||
+                  FalseClass == value_class ||
+                  Integer    == value_class ||
+                  Float      == value_class ||
+                  String     == value_class ||
+                  WAB::Utils.pre_24_fixnum?(value)
+                value
+              else
+                value.dup
+              end
         end
-        cnt
+        c
       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
+      def detect_hash(h)
+        h.each_key { |k| detect_elememt(h, k) }
       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
+      def detect_array(a)
+        a.each_index { |i| detect_elememt(a, i) }
       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
-          value_class = value.class
-          if value.nil? ||
-            TrueClass == value_class ||
-            FalseClass == value_class ||
-            Integer == value_class ||
-            Float == value_class ||
-            String == value_class
-            c = value
-          elsif '2' == RbConfig::CONFIG['MAJOR'] && '4' > RbConfig::CONFIG['MINOR'] && Fixnum == value_class
-            c = value
-          else
-            c = value.clone
-          end
+      def detect_elememt(collection, key)
+        item = collection[key]
+
+        case item
+        when Hash
+          detect_hash(item)
+        when Array
+          detect_array(item)
+        when String
+          element = WAB::Impl::Data.detect_string(item)
+          collection[key] = element unless element == item
         end
-        c
       end
 
     end # Data

data/lib/wab/impl/expr.rb

@@ -0,0 +1,26 @@
+
+module WAB
+  module Impl
+
+    # The base class for expression that are used in the TQL where and filter clauses.
+    class Expr
+
+      def initialize()
+      end
+
+      # Evaluate the expression using the supplied WAB::Data object. Each
+      # expression subclass evaluates differently.
+      #
+      # data:: data object to evaluate against.
+      def eval(_data)
+        false
+      end
+
+      # Return a native Ruby representation of the expression.
+      def native()
+        []
+      end
+
+    end # Expr
+  end # Impl
+end # WAB