lazy_graph 0.1.3 → 0.2.0

data/lib/lazy_graph/builder/dsl.rb

@@ -39,6 +39,8 @@ module LazyGraph
       end
 
       def set_pattern_property(pattern, value)
+        raise 'Trying to set a property without a name' unless pattern.is_a?(String) || pattern.is_a?(Symbol)
+
         pattern = pattern.to_sym
         properties = schema[:patternProperties] ||= {}
         properties[pattern] = \
@@ -51,6 +53,8 @@ module LazyGraph
       end
 
       def set_property(key, value)
+        raise 'Trying to set a property without a name' unless key.is_a?(String) || key.is_a?(Symbol)
+
         key = key.to_sym
         properties = schema[:properties] ||= {}
         properties[key] = \
@@ -63,8 +67,8 @@ module LazyGraph
       end
 
       def object_conditional(
-        name = nil, required: false, pattern_property: false, rule: nil,
-        default: nil, description: nil, **opts, &blk
+        name = nil, required: false, pattern_property: false, rule: nil, copy: nil,
+        default: nil, description: nil, extend: nil, conditions: nil, **opts, &blk
       )
         new_object = {
           type: :object,
@@ -72,20 +76,24 @@ module LazyGraph
           additionalProperties: false,
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
+          validate_presence: required,
           **opts
         }
         @prev_match_cases = @match_cases
         @match_cases = []
-
-        yields(new_object, &blk)
+        yields(new_object, &lambda {
+          blk&.call
+          extend&.call
+        })
 
         object_names = @match_cases.map do |match_case|
           rule = rule_from_when(match_case[:when_clause])
-          set_property(match_case[:name], { type: :object, rule: rule, **match_case[:schema] })
+          set_property(match_case[:name],
+                       { type: :object, rule: rule, rule_location: rule_location, **match_case[:schema] })
           match_case[:name]
         end
 
-        new_object[:rule] = rule_from_first_of(object_names)
+        new_object[:rule] = rule_from_first_of(object_names, conditions)
         @match_cases = @prev_match_cases
         required(name) if required && default.nil? && rule.nil?
         pattern_property ? set_pattern_property(name, new_object) : set_property(name, new_object)
@@ -96,23 +104,32 @@ module LazyGraph
         yields(@match_cases.last[:schema], &blk)
       end
 
+      def rule_location
+        @dir ||= File.expand_path(File.dirname(__FILE__), '../../../../')
+        caller.find { |c| !c.include?(@dir) }.split(':').first(2)
+      end
+
       def object(
-        name = nil, required: false, pattern_property: false, rule: nil,
-        default: nil, description: nil, **opts, &blk
+        name = nil, required: false, pattern_property: false, rule: nil, copy: nil,
+        default: nil, description: nil, extend: nil, **opts, &blk
       )
         rule ||= rule_from_when(opts.delete(:when)) if opts[:when]
         rule ||= rule_from_first_of(opts.delete(:first_of)) if opts[:first_of]
+        rule ||= rule_from_copy(copy)
         new_object = {
           type: :object,
           properties: {},
           additionalProperties: false,
-
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
-        yields(new_object, &blk)
+        yields(new_object, &lambda {
+          blk&.call
+          extend&.call
+        })
         required(name) if required && default.nil? && rule.nil?
         pattern_property ? set_pattern_property(name, new_object) : set_property(name, new_object)
       end
@@ -120,14 +137,15 @@ module LazyGraph
       def primitive(
         name = nil, type, required: false, pattern_property: false,
         default: nil, description: nil, enum: nil,
-        rule: nil, **additional_options, &blk
+        rule: nil, copy: nil, **additional_options, &blk
       )
+        rule ||= rule_from_copy(copy)
         new_primitive = {
           type: type,
           **(enum ? { enum: enum } : {}),
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
           **additional_options
         }
         yields(new_primitive, &blk)
@@ -135,8 +153,9 @@ module LazyGraph
         pattern_property ? set_pattern_property(name, new_primitive) : set_property(name, new_primitive)
       end
 
-      def decimal(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
+      def decimal(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
                   **opts, &blk)
+        rule ||= rule_from_copy(copy)
         # Define the decimal schema supporting multiple formats
         new_decimal = {
           anyOf: [
@@ -157,7 +176,8 @@ module LazyGraph
           type: :decimal,
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
         yields(new_decimal, &blk)
@@ -165,8 +185,9 @@ module LazyGraph
         pattern_property ? set_pattern_property(name, new_decimal) : set_property(name, new_decimal)
       end
 
-      def timestamp(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
+      def timestamp(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
                     **opts, &blk)
+        rule ||= rule_from_copy(copy)
         new_timestamp = {
           anyOf: [
             {
@@ -184,7 +205,8 @@ module LazyGraph
           type: :timestamp, # Custom extended type
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
         yields(new_timestamp, &blk)
@@ -192,15 +214,17 @@ module LazyGraph
         pattern_property ? set_pattern_property(name, new_timestamp) : set_property(name, new_timestamp)
       end
 
-      def time(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
+      def time(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
                **opts, &blk)
+        rule ||= rule_from_copy(copy)
         new_time = {
           type: :time, # Custom extended type
           # Matches HH:mm[:ss[.SSS]]
           pattern: '^\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?$',
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
         yields(new_time, &blk)
@@ -208,8 +232,9 @@ module LazyGraph
         pattern_property ? set_pattern_property(name, new_time) : set_property(name, new_time)
       end
 
-      def date(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
+      def date(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
                **opts, &blk)
+        rule ||= rule_from_copy(copy)
         new_date = {
           anyOf: [
             {
@@ -221,7 +246,8 @@ module LazyGraph
           type: :date, # Custom extended type
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
+          validate_presence: required,
           **opts
         }
         yields(new_date, &blk)
@@ -232,10 +258,11 @@ module LazyGraph
       %i[boolean string const integer number null].each do |type|
         define_method(type) do |
           name = nil, required: false, pattern_property: false,
-          default: nil, description: nil, enum: nil, rule: nil, **additional_options, &blk|
+          default: nil, description: nil, enum: nil, rule: nil, copy: nil,
+          **additional_options, &blk|
           primitive(
             name, type, required: required, pattern_property: pattern_property, enum: enum,
-                        default: default, rule: rule, description: description,
+                        default: default, rule: rule, rule_location: rule_location, description: description,
                         **additional_options, &blk
           )
         end
@@ -253,17 +280,18 @@ module LazyGraph
         schema[:anyOf] = (schema[:any_of] || []).concat(any_of).uniq
       end
 
-      def array(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil,
-                type: :object, **opts, &blk)
+      def array(name = nil, required: false, pattern_property: false, default: nil, description: nil, rule: nil, copy: nil,
+                type: :object, extend: nil, **opts, &block)
+        rule ||= rule_from_copy(copy)
         new_array = {
           type: :array,
           **(!default.nil? ? { default: default } : {}),
           **(description ? { description: description } : {}),
-          **(rule ? { rule: rule } : {}),
+          **(rule ? { rule: rule, rule_location: rule_location } : {}),
           **opts,
           items: { properties: {} }.tap do |items|
             yields(items) do
-              send(type, :items, &blk)
+              send(type, :items, extend: extend, &block)
             end
           end[:properties][:items]
         }
@@ -276,6 +304,7 @@ module LazyGraph
       end
 
       def yields(other)
+        raise ArgumentError, 'Builder DSL used outside of rules module' unless schema
         return unless block_given?
 
         prev_schema = schema
@@ -284,6 +313,12 @@ module LazyGraph
         self.schema = prev_schema
       end
 
+      def rule_from_copy(copy)
+        return unless copy
+
+        "${#{copy}}"
+      end
+
       def rule_from_when(when_clause)
         inputs = when_clause.keys
         conditions = when_clause
@@ -296,17 +331,19 @@ module LazyGraph
         }
       end
 
-      def rule_from_first_of(prop_list)
+      def rule_from_first_of(prop_list, conditions = nil)
+        prop_list += conditions.keys if conditions
         {
           inputs: prop_list,
-          calc: "itself.get_first_of(:#{prop_list.join(', :')})"
+          calc: "itself.get_first_of(:#{prop_list.join(', :')})",
+          **(conditions ? { conditions: conditions } : {})
         }
       end
 
       def depends_on(*dependencies)
         @resolved_dependencies ||= Hash.new do |h, k|
-          send(k) # Load dependency once
           h[k] = true
+          send(k) # Load dependency once
         end
         dependencies.each(&@resolved_dependencies.method(:[]))
       end

data/lib/lazy_graph/builder.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # Subclass LazyGraph::Builder to create new builder classes
 # which can be used to easily build a rule-set to be used as a LazyGraph.
 #
@@ -6,15 +7,14 @@ require_relative 'builder/dsl'
 
 module LazyGraph
   class Builder
-
     # Cache up to a fixed number of graphs, context and queries
     BUILD_CACHE_CONFIG = {
       # Store up to 1000 graphs
-      graph: {size: 1000, cache: {}},
+      graph: { size: ENV.fetch('LAZY_GRAPH_GRAPH_CACHE_MAX_ENTRIES', 1000).to_i, cache: {} },
       # Store up to 5000 configs
-      context: {size: 5000, cache: {}},
+      context: { size: ENV.fetch('LAZY_GRAPH_CONTEXT_CACHE_MAX_ENTRIES', 5000).to_i, cache: {} },
       # Store up to 5000 queries
-      query: {size: 5000, cache: {}}
+      query: { size: ENV.fetch('LAZY_GRAPH_QUERY_CACHE_MAX_ENTRIES', 5000).to_i, cache: {} }
     }.compare_by_identity.freeze
 
     include DSL
@@ -23,15 +23,25 @@ module LazyGraph
     attr_accessor :schema
 
     def initialize(schema: { type: 'object', properties: {} }) = @schema = schema
-    def build!(debug: false, validate: false) = @schema.to_lazy_graph(debug: debug, validate: validate, helpers: self.class.helper_modules)
-    def context(value, debug: false, validate: false) = build!(debug: debug, validate: validate).context(value)
-    def eval!(context, *value, debug: false, validate: false) = context(context, validate: validate, debug: debug).query(*value)
+    def context(value, debug: false, validate: true) = build!(debug: debug, validate: validate).context(value)
+
+    def eval!(context, *value, debug: false,
+              validate: true) = context(context, validate: validate, debug: debug).get(*value)
+    alias feed context
+
+    def build!(debug: false, validate: true) = @schema.to_lazy_graph(
+      debug: debug,
+      validate: validate,
+      helpers: self.class.helper_modules,
+      namespace: self.class
+    )
 
     def self.rules_module(name, schema = { type: 'object', properties: {} }, &blk)
       rules_modules[:properties][name.to_sym] = { type: :object, properties: schema }
       module_body_func_name = :"_#{name}"
       define_method(module_body_func_name, &blk)
       define_method(name) do |**args, &inner_blk|
+        @path = @path.nil? ? "#{name}" : "#{@path}+#{name}" unless @path.to_s.include?(name.to_s)
         send(module_body_func_name, **args, &inner_blk)
         self
       end
@@ -52,6 +62,8 @@ module LazyGraph
       attr_reader :helper_modules
     end
 
+    def self.register_helper_modules(*mods) = mods.each(&method(:register_helper_module))
+
     def self.register_helper_module(mod)
       (@helper_modules ||= []) << mod
     end
@@ -64,6 +76,12 @@ module LazyGraph
       @helper_modules = nil
     end
 
+    def self.clear_caches!
+      clear_rules_modules!
+      clear_helper_modules!
+      BUILD_CACHE_CONFIG.each_value { |v| v[:cache].clear }
+    end
+
     def self.rules_modules
       @rules_modules ||= {
         type: :object,
@@ -87,8 +105,8 @@ module LazyGraph
       }
     end
 
-    def self.eval!(modules:, context:, query:, debug: false, validate: false)
-      builder = cache_as(:graph, [modules, debug, validate].hash) do
+    def self.eval!(modules:, context:, query:, debug: false, validate: true)
+      graph = cache_as(:graph, [modules, debug, validate]) do
         invalid_modules = modules.reject { |k, _v| rules_modules[:properties].key?(k.to_sym) }
         return format_error_response('Invalid Modules', invalid_modules.keys.join(',')) unless invalid_modules.empty?
 
@@ -99,21 +117,23 @@ module LazyGraph
         builder = build_modules(modules)
         return builder if builder.is_a?(Hash)
 
-        builder
+        builder.build!(debug: debug, validate: validate)
       end
 
-      context_result = cache_as(:context, [builder, context]) do
-        evaluate_context(builder, context, debug: debug, validate: validate)
+      context_result = cache_as(:context, [graph, context]) do
+        build_context(graph, context)
       end
 
-      return context_result if context_result.is_a?(Hash) && context_result[:type] == :error
-
-      query_result = cache_as(:query, [context_result, query]){ context_result.query(*(query || '')) }
+      return context_result if context_result.is_a?(Hash) && context_result[:type].equal?(:error)
 
-      {
-        type: :success,
-        result: query_result
-      }
+      cache_as(:query, [context_result, query]) do
+        HashUtils.strip_missing(
+          {
+            type: :success,
+            result: context_result.resolve(*(query || ''))
+          }
+        )
+      end
     rescue SystemStackError => e
       LazyGraph.logger.error(e.message)
       LazyGraph.logger.error(e.backtrace.join("\n"))
@@ -132,9 +152,12 @@ module LazyGraph
       cache.delete(cache.keys.first) while cache.size > max_size
     end
 
+    def to_str
+      "LazyGraph(modules=#{@path})"
+    end
+
     private_class_method def self.method_missing(method_name, *args, &block) = new.send(method_name, *args, &block)
     private_class_method def self.respond_to_missing?(_, _ = false) = true
-
     private_class_method def self.validate_modules(input_options)
       JSON::Validator.validate!(rules_modules, input_options)
       ''
@@ -156,15 +179,19 @@ module LazyGraph
         acc.send(k, **v.to_h.transform_keys(&:to_sym))
       end
     rescue ArgumentError => e
+      LazyGraph.logger.error(e.message)
+      LazyGraph.logger.error(e.backtrace.join("\n"))
       format_error_response('Invalid Module Argument', e.message)
-      LazyGraph.logger.error(e.backtrace)
     end
 
-    private_class_method def self.evaluate_context(builder, context, debug: false, validate: false)
-      builder.context(context, debug: debug, validate: validate)
-    rescue ArgumentError => e
+    private_class_method def self.build_context(graph, context)
+      graph.context(context)
+    rescue StandardError => e
+      if graph.debug?
+        LazyGraph.logger.error(e.message)
+        LazyGraph.logger.error(e.backtrace.join("\n"))
+      end
       format_error_response('Invalid Context Input', e.message)
-      LazyGraph.logger.error(e.backtrace)
     end
   end
 end

data/lib/lazy_graph/builder_group.rb

@@ -2,8 +2,13 @@ module LazyGraph
   class BuilderGroup
     # A builder group is simply a named colleciton of builders (each a subclass of LazyGraph::Builder)
     # That can be reloaded in bulk, and exposed via a simple HTTP server interface.
-    def self.bootstrap!(reload_paths: [], listen: ENV['RACK_ENV'] == 'development')
+    # If a script file defining a builder group is run directly, it will start a Puma server
+    # to host itself
+    def self.bootstrap!(reload_paths: nil, exclude_paths: [], listen: Environment.development?, enable_server: true)
+      bootstrap_script_name = caller.drop_while { |r| r =~ /builder_group/ }[0][/[^:]+/]
+      reload_paths ||= File.join(File.dirname(bootstrap_script_name), '**/*.rb')
       reload_paths = Array(reload_paths)
+
       Module.new do
         define_singleton_method(:included) do |base|
           def base.each_builder(const = self, &blk)
@@ -18,40 +23,48 @@ module LazyGraph
             end
           end
 
-          def base.server
-            LazyGraph::Server.new(
+          def base.rack_app(**opts)
+            unless defined?(Rack)
+              raise AbortError,
+                    'You must install rack first to be able to run a LazyGraph BuilderGroup as a server'
+            end
+
+            LazyGraph::RackApp.new(
               routes: each_builder.map do |builder|
                 [
-                  builder.to_s.downcase.gsub('::', '/').gsub(/^#{name.downcase}/, ''),
+                  builder.to_s.downcase.gsub('::', '/').gsub(/^#{name.to_s.downcase}/, ''),
                   builder
                 ]
-              end.to_h
+              end.to_h,
+              **opts
             )
           end
 
-          base.define_singleton_method(:reload_lazy_graphs!) do
-            each_builder do |builder|
-              builder.clear_rules_modules!
-              builder.clear_helper_modules!
-            end
+          base.define_singleton_method(:reload_lazy_graphs!) do |clear_previous: false|
+            each_builder(&:clear_caches!) if clear_previous
 
-            reload_paths.flat_map { |p| Dir[p] }.each do |file|
-              load file
+            reload_paths.flat_map { |p|
+              Dir[p]
+            }.-([bootstrap_script_name]).sort_by { |file| file.count(File::SEPARATOR) }.each do |file|
+              load file unless exclude_paths.any? { |p| p =~ file }
             rescue StandardError => e
               LazyGraph.logger.error("Failed to load #{file}: #{e.message}")
             end
           end
 
-          base.reload_lazy_graphs!
+          base.reload_lazy_graphs! if reload_paths.any?
 
-          return unless listen
+          if listen && defined?(Listen)
+            Listen.to(*reload_paths.map { |p| p.gsub(%r{(?:/\*\*)*/\*\.rb}, '') }) do
+              base.reload_lazy_graphs!(clear_previous: true)
+            end.start
+          end
 
-          require 'listen'
-          Listen.to(*reload_paths.map { |p| p.gsub(%r{(?:/\*\*)*/\*\.rb}, '') }) do
-            base.reload_lazy_graphs!
-          end.start
+          CLI.invoke!(base.rack_app) if enable_server && bootstrap_script_name == $0
         end
       end
     end
   end
+
+  define_singleton_method(:bootstrap_app!, &BuilderGroup.method(:bootstrap!))
 end

data/lib/lazy_graph/cli.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LazyGraph
+  class CLI
+    # A builder group rack-app can be exposed via a simple rack based HTTP server
+    # with routes corresponding to each builder class deeply nested
+    # withhin the builder group module.
+    def self.invoke!(rack_app)
+      require 'etc'
+      require 'optparse'
+      require 'rack'
+
+      options = {
+        port: 9292,
+        workers: (Environment.development? ? 1 : Etc.nprocessors)
+      }
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options]"
+
+        opts.on('-p PORT', '--port PORT', Integer, "Set the port (default: #{options[:port]})") do |p|
+          options[:port] = p
+        end
+
+        opts.on('-w WORKERS', '--workers WORKERS', Integer,
+                "Set the number of workers (default: #{options[:workers]})") do |w|
+          options[:workers] = w
+        end
+
+        opts.on('-h', '--help', 'Print this help') do
+          puts opts
+          exit
+        end
+      end.parse!
+      # A builder group can be exposed as a simple rack based HTTP server
+      # with routes corresponding to each builder class deeply nested
+      # withhin the builder group module.
+
+      RackServer.new(
+        Rack::Builder.new do
+          use Rack::Lint if Environment.development?
+          run rack_app
+        end
+      ).start(port: options[:port], workers: options[:workers])
+    end
+  end
+end

data/lib/lazy_graph/context.rb

@@ -11,17 +11,34 @@ module LazyGraph
       graph.validate!(input) if [true, 'input'].include?(graph.validate)
       @graph = graph
       @input = input
+      @graph.root_node.properties.each_key do |key|
+        define_singleton_method(key) { get(key) }
+      end
+    end
+
+    def get_json(path)
+      HashUtils.strip_missing(get(path))
+    end
+
+    def get(path)
+      result = resolve(path)
+      raise result[:error] if result[:err]
+
+      result[:output]
     end
 
-    def query(paths)
-      paths.is_a?(Array) ? paths.map { |path| resolve(path) } : resolve(paths)
+    def debug(path)
+      result = resolve(path)
+      raise result[:error] if result[:err]
+
+      result[:debug_trace]
     end
 
     def resolve(path)
       @input = @graph.root_node.fetch_item({ input: @input }, :input, nil)
 
-      query = PathParser.parse(path, true)
-      stack = StackPointer.new(nil, @input, 0, :'$', nil)
+      query = PathParser.parse(path, strip_root: true)
+      stack = StackPointer.new(nil, @input, 0, 0, :'$', nil)
       stack.root = stack
 
       result = @graph.root_node.resolve(query, stack)
@@ -32,18 +49,20 @@ module LazyGraph
         stack.frame[:DEBUG] = nil
       end
       {
-        output: HashUtils.strip_invalid(result),
-        debug_trace: HashUtils.strip_invalid(debug_trace)
+        output: result,
+        debug_trace: debug_trace
       }
-    rescue LazyGraph::AbortError => e
+    rescue AbortError, ValidationError => e
       {
-        output: { err: e.message, status: :abort }
+        output: nil, err: e.message, status: :abort, error: e
       }
     rescue StandardError => e
-      LazyGraph.logger.error(e.message)
-      LazyGraph.logger.error(e.backtrace)
+      if @graph.debug?
+        LazyGraph.logger.error(e.message)
+        LazyGraph.logger.error(e.backtrace.join("\n"))
+      end
       {
-        output: { err: e.message, backtrace: e.backtrace }
+        output: nil, err: e.message, backtrace: e.backtrace, error: e
       }
     end
 
@@ -54,9 +73,15 @@ module LazyGraph
           q.text 'graph='
           q.pp(@graph)
         end
+        q.group do
+          q.text 'input='
+          q.pp(@input)
+        end
       end
     end
 
-    alias [] query
+    def [](*parts)
+      get(parts.map { |p| p.is_a?(Integer) ? "[#{p}]" : p.to_s }.join('.').gsub('.[', '['))
+    end
   end
 end

data/lib/lazy_graph/environment.rb

@@ -0,0 +1,6 @@
+module LazyGraph
+  module Environment
+    def self.development? = env == 'development'
+    def self.env = ENV.fetch('RACK_ENV', 'development')
+  end
+end