json-schema_dsl 1.0.0

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'json/schema_dsl'
+require 'pry'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/json-schema_dsl.gemspec

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json/schema_dsl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'json-schema_dsl'
+  spec.version       = Json::SchemaDsl::VERSION
+  spec.authors       = ['Paul Martensen']
+  spec.email         = ['paul.martensen@gmx.de']
+
+  spec.summary       = 'A builder dsl to programatically build json-schemas'
+  spec.description   = 'A builder dsl to programatically build
+                        json-schemas that are composable and reusable.'
+  spec.homepage      = 'https://github.com/lokalportal/json-schema_dsl'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '< 6.0'
+  spec.add_dependency 'docile', '< 2'
+  spec.add_dependency 'dry-struct', '~> 1.0'
+  spec.add_dependency 'dry-types', '~> 1.0'
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '0.74.0'
+  spec.add_development_dependency 'rubocop-rspec', '1.36.0'
+  spec.add_development_dependency 'spring'
+  spec.add_development_dependency 'stackprof'
+end

data/lib/json/schema_dsl.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/object'
+require 'docile'
+require 'dry-struct'
+require 'dry-types'
+
+require 'json/schema_dsl/version'
+require 'json/schema_dsl/types'
+require 'json/schema_dsl/configuration'
+require 'json/schema_dsl/ast_node'
+require 'json/schema_dsl/entity'
+
+%w[null boolean numeric integer string object array].each do |type|
+  require "json/schema_dsl/#{type}"
+end
+
+require 'json/schema_dsl/builder'
+require 'json/schema_dsl/renderer'
+require 'json/schema_dsl/proxy'
+
+module JSON
+  # This module provides the base that it includes with the methods to build new json-schemas.
+  module SchemaDsl
+    class Error < StandardError; end
+
+    class << self
+      delegate(:type_defaults,
+               :reset_type_defaults!,
+               :add_defaults_for,
+               to: ::JSON::SchemaDsl::Builder)
+
+      DEFAULT_TYPES = JSON::SchemaDsl::Entity
+                      .descendants.dup.push(JSON::SchemaDsl::Entity).freeze
+      DEFAULT_RENDERERS = [Renderers::Desugar,
+                           Renderers::Multiplexer,
+                           Renderers::Alias,
+                           Renderers::Filter].freeze
+
+      attr_writer :registered_renderers
+
+      # @return [Array<Class>] The renderer classes that schema_dsl will use in the renderer
+      def registered_renderers
+        @registered_renderers ||= DEFAULT_RENDERERS.dup
+      end
+
+      # Resets the registered_renderers to the default settings
+      # @return [Array<Class>] The renderer classes that schema_dsl will use in the renderer
+      def reset_registered_renderers!
+        @registered_renderers = DEFAULT_RENDERERS.dup
+      end
+
+      # @return [Array<Class>] The registered types. These are used to add new dsl
+      #   and builder methods.
+      def registered_types
+        @registered_types ||= DEFAULT_TYPES.dup
+      end
+
+      # @param [Class] type A new type to be registered. This will define new builder and dsl
+      #   methods for that type.
+      # @return [Array<Class>] The registered types.
+      def register_type(type)
+        registered_types.push(type).tap { define_type_methods(type) }
+      end
+
+      # Resets schema_dsl back to default. Removes all dsl methods and redefines
+      #   them with the default types.
+      def reset_schema_dsl!
+        type_methods.each { |tm| remove_method tm }
+        @registered_types = DEFAULT_TYPES.dup
+        define_schema_dsl!
+      end
+
+      # Defines the dsl for all registered types.
+      def define_schema_dsl!
+        registered_types.map { |t| define_type_methods(t) }
+      end
+
+      # Defines builder methods for the given type.
+      # @param [Class] type A class that is a {JSON::SchemaDsl::AstNode}
+      def define_type_methods(type)
+        JSON::SchemaDsl::Builder.define_builder_method(type)
+        builder = JSON::SchemaDsl::Builder[type]
+        define_method(type_method_name(type)) do |name = nil, **attributes, &block|
+          builder.build(name, **attributes, scope: self, &block)
+        end
+      end
+
+      # Reset all settings to default.
+      def reset!
+        reset_registered_renderers!
+        reset_type_defaults!
+        reset_schema_dsl!
+      end
+
+      # @return [JSON::SchemaDsl::Proxy] a new proxy to build schemas.
+      def proxy
+        ::JSON::SchemaDsl::Proxy.new
+      end
+
+      # @return [Array<Symbol>] An array of all type methods
+      def type_methods
+        registered_types.map { |t| type_method_name(t).to_sym } & instance_methods
+      end
+
+      # @param [Class] type The class for which a method will be defined.
+      # @return [String] the name of the new method.
+      def type_method_name(type)
+        type.type_method_name || 'entity'
+      end
+    end
+
+    define_schema_dsl!
+  end
+end

data/lib/json/schema_dsl/array.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module JSON
+  module SchemaDsl
+    # Type that validates a json entity to be an array.
+    #
+    # @see https://json-schema.org/understanding-json-schema/reference/array.html
+    class Array < Entity
+      attribute?(:unique_items, Types::Bool)
+      attribute?(:additional_items, Types::Bool)
+      attribute?(:min_items, Types::Bool)
+      attribute?(:max_items, Types::Bool)
+      attribute?(:items, Types::Any)
+    end
+  end
+end

data/lib/json/schema_dsl/ast_node.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module JSON
+  module SchemaDsl
+    # Methods for an object to be used as an ast node by the renderer
+    # Include this module to define your own types that are not descendants of
+    # Entity. You should still implement two methods to be compatible with the
+    # normal builder class:
+    #
+    # #initialize: Hash -> Self
+    # #to_h: Self -> Hash
+    # .has_attribute?: Symbol -> Boolean
+    module AstNode
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # @param [Symbol] attribute_name The name of the attribute to update.
+      # @param [Object] value The value that will be set for the attribute.
+      # @return [Entity] Since entities themselves are immutable, this method returns a new
+      #   entity with the attribute_name and value pair added.
+      def update(attribute_name, value = nil)
+        self.class.new(to_h.merge(attribute_name => value))
+      end
+
+      # Used to do a simple render of the entity. Since this has no sensible scope while
+      #   rendering, use Builder#render instead.
+      # @see JSON::SchemaDsl::Builder#render
+      def render
+        ::JSON::SchemaDsl::Renderer.new(self).render
+      end
+
+      # The class methods that ast nodes should have
+      module ClassMethods
+        # @return [String] The type that will be used in I.E. `type: 'object'` attributes.
+        #   Also used to give names to the dsl and builder methods.
+        def infer_type
+          type = name.split('::').last.underscore
+          type == 'entity' ? nil : type
+        end
+
+        # @method! type_method_name
+        #   Override this method to set the name of the dsl method for this type.
+        alias type_method_name infer_type
+
+        # Override this to set a custom builder for your type.
+        # @return [Class] A new builder class for this type.
+        def builder
+          ::JSON::SchemaDsl::Builder.define_builder(self)
+        end
+      end
+    end
+  end
+end

data/lib/json/schema_dsl/boolean.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JSON
+  module SchemaDsl
+    # Boolean primitive of json schema.
+    #
+    # @see https://json-schema.org/understanding-json-schema/reference/boolean.html
+    class Boolean < Entity
+    end
+  end
+end

data/lib/json/schema_dsl/builder.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module JSON
+  module SchemaDsl
+    # Builders are used to build entity-structs. They handle building this raw data so
+    # it can then be given to the renderers which modify the structure to be valid json-schema.
+    #
+    # Each type has an associated Builder that is a dynamically generated class.
+    # Since entity-structs are immutable, the builder updates the struct and keeps track of the
+    # latest version of the struct.
+    #
+    # Entity definitions can mostly be treated as data input while most of the logic of building
+    # the entity tree resides in the builders.
+    # @todo Refactor class and remove rubocop exception
+    # rubocop:disable Metrics/ClassLength
+    class Builder
+      class << self
+        attr_accessor :inner_class
+
+        # @param [Class] klass A class that is a subclass of {JSON::SchemaDsl::Entity}.
+        # @return A new builder class that subclasses {JSON::SchemaDsl::Builder}
+        def [](klass)
+          raise ArgumentError, "#{klass} is not a struct." unless klass < AstNode
+
+          registered_builders[klass] ||= klass.builder
+        end
+
+        # @return [Array<JSON::SchemaDsl::Builder>] All builders that have been
+        #   registered so far. Usually builders get automatically registered when
+        #   the associated type is registered.
+        def registered_builders
+          @registered_builders ||= {}
+        end
+
+        # @return [Hash<Symbol, Hash>] Defaults that are applied when a new struct of a
+        #   given type is contsructed. The type symbol is the key and the defaults the value
+        #   of this hash.
+        def type_defaults
+          @type_defaults ||= Hash.new { {} }
+        end
+
+        # Clears the registered type defaults and returns an empty hash.
+        # @return [Hash<Symbol, Hash>]
+        # @see #type_defaults
+        def reset_type_defaults!
+          type_defaults.clear
+        end
+
+        # Adds new defaults for the given type.
+        # @param [Symbol] type The type symbol for the type. Usually the name underscored and
+        #   symbolized. I.e. {JSON::SchemaDsl::Object} => `:object`.
+        # @param [Hash<Symbol, Object>] defaults New defaults that will be merged to
+        #   the existing ones.
+        # @return [Hash<Symbol, Hash>]
+        # @see #type_defaults
+        def add_defaults_for(type, defaults)
+          if type_defaults[type].empty?
+            type_defaults[type] = type_defaults[type].merge(defaults)
+          else
+            type_defaults[type].merge!(defaults)
+          end
+        end
+
+        # Instantiates a new builder instance with a corresponding entity and
+        # applies the attributes and block to construct a complete entity.
+        # @param [#to_s] name The name of the new entity. This is important for the entity
+        #   to be added to properties later. Usually is the name of a property or the pattern
+        #   for a pattern property.
+        # @param [Object] scope The scope will be used as a fallback to evaluate the block.
+        #   If there are any methods that the block does not understand, the scope will
+        #   be called instead.
+        # @param [Hash] attributes The initial attributes that the entity will start with
+        #   before the block is applied.
+        # @param [Proc] block Will be evaluated in the context of the builder. Should contain
+        #  setter methods.
+        #
+        def build(name = nil, scope: nil, **attributes, &block)
+          type     = (attributes[:type] || inner_class.infer_type)&.to_sym
+          defaults = ::JSON::SchemaDsl::Builder
+                     .type_defaults[type].merge(name: name, type: type)
+          builder  = new(inner_class.new(defaults), scope: scope)
+          Docile.dsl_eval(builder, &config_block(attributes, &block))
+        end
+
+        # nodoc
+        def inspect
+          "#<#{class_name} inner_class=#{inner_class}>"
+        end
+
+        # nodoc
+        def class_name
+          name || inner_class.name + 'Builder'
+        end
+
+        # Defines a new method for the builder instance that mirrors the dsl method
+        #   for the given type.
+        # @param [Class] type A class that is a subclass of {JSON::SchemaDsl::Entity}.
+        def define_builder_method(type)
+          type_param = type.type_method_name || 'entity'
+          define_method(type_param) do |name = nil, **attributes, &block|
+            new_child = build_struct(type, name, **attributes, &block)
+            add_child(new_child)
+          end
+        end
+
+        # @param [Class] klass A class that is a subclass of {JSON::SchemaDsl::Entity}.
+        # @return A new builder class that subclasses {JSON::SchemaDsl::Builder}
+        # @see #[]
+        def define_builder(klass)
+          Class.new(self) do
+            self.inner_class = klass
+            klass.schema.keys.map(&:name).each do |name|
+              define_method(name) do |*args, **opts, &block|
+                set(name, *args, **opts, &block)
+              end
+            end
+          end
+        end
+
+        private
+
+        # Combines a set of attributes and a block into a single proc.
+        def config_block(attributes, &block)
+          proc do
+            attributes.each { |k, v| send(k, v) }
+            instance_exec(&block) if block_given?
+          end
+        end
+      end
+
+      attr_reader :inner, :scope
+      delegate :as_json, to: :render
+      delegate :to_h, to: :inner
+
+      # @param [JSON::SchemaDsl::Entity] inner The struct that the builder is supposed
+      #   to update and build up.
+      # @param [Object] scope The scope is used for as a fallback for helper methods.
+      # @see JSON::SchemaDsl::Builder.build
+      def initialize(inner, scope: nil)
+        @inner = inner
+        @scope = scope
+      end
+
+      # Renders the given tree structure into a hash. Note that this hash still has symbol keys.
+      #   The scope used for the render is the same as the builder.
+      # @see JSON::SchemaDsl::Renderer#render
+      def render
+        ::JSON::SchemaDsl::Renderer.new(inner, scope).render
+      end
+
+      private
+
+      def update(type, *args)
+        args = args.first if args.count == 1 && args.is_a?(::Array)
+        @inner = if args.is_a?(::Array)
+                   inner.update(type, *args)
+                 else
+                   inner.update(type, args)
+                 end
+      end
+
+      def build_struct(type, name = nil, **attributes, &block)
+        builder = self.class[type || attributes[:type].constantize]
+        builder.build(name, **attributes, scope: scope, &block)
+      end
+
+      def method_missing(meth, *args, &block)
+        return super unless scope&.respond_to?(meth, true)
+
+        maybe_child = scope.send(meth, *args, &block)
+        maybe_child.respond_to?(:render) &&
+          add_child(maybe_child)
+        maybe_child
+      end
+
+      def respond_to_missing?(meth, priv)
+        return super unless scope
+
+        scope.respond_to?(meth, priv)
+      end
+
+      def inspect
+        "#<#{self.class.class_name} \n  scope = #{scope}\n  inner = #{inner}> "
+      end
+
+      def set(name, *args, **opts, &block)
+        args = extract_args(name, args, opts, &block)
+        return inner.send(name) unless args
+
+        @inner = update(name, args)
+      end
+
+      def extract_args(name, args, opts, &block)
+        if block.present? || !inner.class.has_attribute?(name) || opts[:type].present?
+          return build_struct(Object, **opts, &block)
+        end
+
+        args.presence || opts.presence
+      end
+
+      def add_child(child)
+        children(children | [child])
+        child
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end