senko 0.1.0

data/lib/senko/code_generator.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+require_relative 'format'
+
+module Senko
+  class CodeGenerator
+    SUPPORTED_KEYS = %w[
+      type enum const minimum maximum exclusiveMinimum exclusiveMaximum multipleOf
+      minLength maxLength pattern required properties additionalProperties allOf anyOf oneOf not
+      minItems maxItems uniqueItems prefixItems items contains minContains maxContains
+      minProperties maxProperties patternProperties propertyNames dependentRequired
+    ].freeze
+
+    def self.generate(schema)
+      new(schema).generate
+    rescue UnsupportedSchema
+      nil
+    end
+
+    class UnsupportedSchema < StandardError; end
+
+    def initialize(schema)
+      @schema = deep_stringify(schema)
+      @regexps = []
+      @constants = []
+    end
+
+    def generate
+      expression = compile_schema(@schema, 'data')
+      regexps = @regexps
+      constants = @constants
+      eval("lambda { |data| #{expression} }", binding, __FILE__, __LINE__)
+    end
+
+    private
+
+    def compile_schema(schema, variable)
+      case schema
+      when true
+        'true'
+      when false
+        'false'
+      when Hash
+        compile_hash_schema(schema, variable)
+      else
+        raise UnsupportedSchema
+      end
+    end
+
+    def compile_hash_schema(schema, variable)
+      unsupported = schema.keys.map(&:to_s) - SUPPORTED_KEYS
+      raise UnsupportedSchema unless unsupported.empty?
+
+      checks = []
+      checks << compile_type(schema['type'], variable) if schema.key?('type')
+      checks << compile_enum(schema['enum'], variable) if schema.key?('enum')
+      checks << compile_const(schema['const'], variable) if schema.key?('const')
+      checks.concat(compile_numeric(schema, variable))
+      checks.concat(compile_string(schema, variable))
+      checks.concat(compile_array(schema, variable))
+      checks.concat(compile_object(schema, variable))
+      checks.concat(compile_applicators(schema, variable))
+      checks.empty? ? 'true' : checks.join(' && ')
+    end
+
+    def compile_type(type, variable)
+      types = type.is_a?(Array) ? type : [type]
+      parts = types.map do |name|
+        case name.to_s
+        when 'null' then "#{variable}.nil?"
+        when 'boolean' then "#{variable} == true || #{variable} == false"
+        when 'integer' then "(#{variable}.is_a?(Integer) || (#{variable}.is_a?(Float) && #{variable}.finite? && #{variable} == #{variable}.to_i) || (#{variable}.is_a?(BigDecimal) && #{variable}.finite? && #{variable} == #{variable}.to_i))"
+        when 'number' then "#{variable}.is_a?(Integer) || #{variable}.is_a?(Float) || #{variable}.is_a?(BigDecimal)"
+        when 'string' then "#{variable}.is_a?(String)"
+        when 'array' then "#{variable}.is_a?(Array)"
+        when 'object' then "#{variable}.is_a?(Hash)"
+        else raise UnsupportedSchema
+        end
+      end
+      "(#{parts.join(' || ')})"
+    end
+
+    def compile_enum(values, variable)
+      index = push_constant(values)
+      "constants[#{index}].any? { |value| value == #{variable} }"
+    end
+
+    def compile_const(value, variable)
+      index = push_constant(value)
+      "(constants[#{index}] == #{variable})"
+    end
+
+    def compile_numeric(schema, variable)
+      checks = []
+      guard = "(#{variable}.is_a?(Integer) || #{variable}.is_a?(Float) || #{variable}.is_a?(BigDecimal))"
+      checks << "(!#{guard} || #{variable} >= #{schema['minimum'].inspect})" if schema.key?('minimum')
+      checks << "(!#{guard} || #{variable} > #{schema['exclusiveMinimum'].inspect})" if schema.key?('exclusiveMinimum')
+      checks << "(!#{guard} || #{variable} <= #{schema['maximum'].inspect})" if schema.key?('maximum')
+      checks << "(!#{guard} || #{variable} < #{schema['exclusiveMaximum'].inspect})" if schema.key?('exclusiveMaximum')
+      if schema.key?('multipleOf')
+        checks << "(!#{guard} || (BigDecimal(#{variable}.to_s) % BigDecimal(#{schema['multipleOf'].inspect}.to_s)).zero?)"
+      end
+      checks
+    end
+
+    def compile_string(schema, variable)
+      checks = []
+      guard = "#{variable}.is_a?(String)"
+      checks << "(!#{guard} || #{variable}.length >= #{schema['minLength'].to_i})" if schema.key?('minLength')
+      checks << "(!#{guard} || #{variable}.length <= #{schema['maxLength'].to_i})" if schema.key?('maxLength')
+      if schema.key?('pattern')
+        index = push_regexp(Regexp.new(Senko::Format.ecma_pattern_source(schema.fetch('pattern').to_s)))
+        checks << "(!#{guard} || #{variable}.match?(regexps[#{index}]))"
+      end
+      checks
+    end
+
+    def compile_object(schema, variable)
+      object_checks = []
+      return [] unless object_keyword?(schema)
+
+      object_checks << "#{variable}.length >= #{schema['minProperties'].to_i}" if schema.key?('minProperties')
+      object_checks << "#{variable}.length <= #{schema['maxProperties'].to_i}" if schema.key?('maxProperties')
+      object_checks.concat(schema.fetch('required', []).map { |key| "#{variable}.key?(#{key.to_s.inspect})" })
+      object_checks.concat(compile_properties(schema.fetch('properties', {}), variable))
+      object_checks.concat(compile_pattern_properties(schema.fetch('patternProperties', {}), variable))
+      object_checks << compile_property_names(schema.fetch('propertyNames'), variable) if schema.key?('propertyNames')
+      if schema.key?('dependentRequired')
+        object_checks << compile_dependent_required(schema.fetch('dependentRequired'),
+                                                    variable)
+      end
+      object_checks << compile_additional_properties(schema, variable) if schema.key?('additionalProperties')
+      ["(!#{variable}.is_a?(Hash) || (#{object_checks.join(' && ')}))"]
+    end
+
+    def compile_array(schema, variable)
+      array_checks = []
+      return [] unless array_keyword?(schema)
+
+      array_checks << "#{variable}.length >= #{schema['minItems'].to_i}" if schema.key?('minItems')
+      array_checks << "#{variable}.length <= #{schema['maxItems'].to_i}" if schema.key?('maxItems')
+      array_checks << "#{variable}.uniq.length == #{variable}.length" if schema['uniqueItems'] == true
+      array_checks.concat(compile_prefix_items(schema.fetch('prefixItems', []), variable))
+      array_checks << compile_items(schema, variable) if schema.key?('items')
+      array_checks << compile_contains(schema, variable) if schema.key?('contains')
+      ["(!#{variable}.is_a?(Array) || (#{array_checks.join(' && ')}))"]
+    end
+
+    def array_keyword?(schema)
+      %w[minItems maxItems uniqueItems prefixItems items contains].any? { |key| schema.key?(key) }
+    end
+
+    def object_keyword?(schema)
+      %w[
+        minProperties maxProperties required properties patternProperties additionalProperties
+        propertyNames dependentRequired
+      ].any? { |key| schema.key?(key) }
+    end
+
+    def compile_properties(properties, variable)
+      properties.map do |key, subschema|
+        child = "#{variable}[#{key.to_s.inspect}]"
+        "(!#{variable}.key?(#{key.to_s.inspect}) || (#{compile_schema(subschema, child)}))"
+      end
+    end
+
+    def compile_pattern_properties(pattern_properties, variable)
+      pattern_properties.map do |pattern, subschema|
+        index = push_regexp(Regexp.new(Senko::Format.ecma_pattern_source(pattern.to_s)))
+        "#{variable}.all? { |key, value| !key.match?(regexps[#{index}]) || (#{compile_schema(subschema, 'value')}) }"
+      end
+    end
+
+    def compile_property_names(subschema, variable)
+      "#{variable}.keys.all? { |key| #{compile_schema(subschema, 'key')} }"
+    end
+
+    def compile_dependent_required(requirements, variable)
+      requirements.map do |property, dependencies|
+        deps = dependencies.map(&:to_s)
+        "(!#{variable}.key?(#{property.to_s.inspect}) || #{deps.inspect}.all? { |dependency| #{variable}.key?(dependency) })"
+      end.join(' && ')
+    end
+
+    def compile_additional_properties(schema, variable)
+      value = schema.fetch('additionalProperties')
+      return 'true' if value == true
+      raise UnsupportedSchema unless value == false
+
+      known = schema.fetch('properties', {}).keys.map(&:to_s)
+      pattern_indexes = schema.fetch('patternProperties', {}).keys.map do |pattern|
+        push_regexp(Regexp.new(Senko::Format.ecma_pattern_source(pattern.to_s)))
+      end
+      pattern_check = pattern_indexes.map { |index| "key.match?(regexps[#{index}])" }.join(' || ')
+      allowed = "#{known.inspect}.include?(key)"
+      allowed = "(#{allowed} || #{pattern_check})" unless pattern_check.empty?
+      "#{variable}.keys.all? { |key| #{allowed} }"
+    end
+
+    def compile_prefix_items(prefix_items, variable)
+      prefix_items.each_with_index.map do |subschema, index|
+        "(#{variable}.length <= #{index} || (#{compile_schema(subschema, "#{variable}[#{index}]")}))"
+      end
+    end
+
+    def compile_items(schema, variable)
+      start_index = Array(schema['prefixItems']).length
+      "#{variable}.each_with_index.all? { |item, index| index < #{start_index} || (#{compile_schema(
+        schema.fetch('items'), 'item'
+      )}) }"
+    end
+
+    def compile_contains(schema, variable)
+      min = schema.fetch('minContains', 1).to_i
+      max = schema.key?('maxContains') ? schema.fetch('maxContains').to_i : nil
+      count = "#{variable}.count { |item| #{compile_schema(schema.fetch('contains'), 'item')} }"
+      if max
+        "((__senko_count = #{count}) >= #{min} && __senko_count <= #{max})"
+      else
+        "(#{count} >= #{min})"
+      end
+    end
+
+    def compile_applicators(schema, variable)
+      checks = []
+      if schema.key?('allOf')
+        checks << schema['allOf'].map { |subschema|
+          "(#{compile_schema(subschema, variable)})"
+        }.join(' && ')
+      end
+      if schema.key?('anyOf')
+        checks << schema['anyOf'].map { |subschema|
+          "(#{compile_schema(subschema, variable)})"
+        }.join(' || ')
+      end
+      if schema.key?('oneOf')
+        checks << "(#{schema['oneOf'].map do |subschema|
+          "(#{compile_schema(subschema, variable)} ? 1 : 0)"
+        end.join(' + ')} == 1)"
+      end
+      checks << "!(#{compile_schema(schema['not'], variable)})" if schema.key?('not')
+      checks
+    end
+
+    def push_regexp(regexp)
+      @regexps << regexp
+      @regexps.length - 1
+    end
+
+    def push_constant(value)
+      @constants << value
+      @constants.length - 1
+    end
+
+    def deep_stringify(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, child), result|
+          result[key.to_s] = deep_stringify(child)
+        end
+      when Array
+        value.map { |child| deep_stringify(child) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/senko/compiler/instruction.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Senko
+  module Instructions
+    TYPE_NULL = 0b0000001
+    TYPE_BOOLEAN = 0b0000010
+    TYPE_INTEGER = 0b0000100
+    TYPE_NUMBER = 0b0001100
+    TYPE_STRING = 0b0010000
+    TYPE_ARRAY = 0b0100000
+    TYPE_OBJECT = 0b1000000
+
+    TYPE_MAP = {
+      'null' => TYPE_NULL,
+      'boolean' => TYPE_BOOLEAN,
+      'integer' => TYPE_INTEGER,
+      'number' => TYPE_NUMBER,
+      'string' => TYPE_STRING,
+      'array' => TYPE_ARRAY,
+      'object' => TYPE_OBJECT
+    }.freeze
+
+    KEYWORDS = {
+      false_schema: 'false',
+      type: 'type',
+      enum: 'enum',
+      const: 'const',
+      multiple_of: 'multipleOf',
+      maximum: 'maximum',
+      minimum: 'minimum',
+      max_length: 'maxLength',
+      min_length: 'minLength',
+      pattern: 'pattern',
+      max_items: 'maxItems',
+      min_items: 'minItems',
+      unique_items: 'uniqueItems',
+      prefix_items: 'prefixItems',
+      items: 'items',
+      contains: 'contains',
+      max_properties: 'maxProperties',
+      min_properties: 'minProperties',
+      required: 'required',
+      properties: 'properties',
+      pattern_properties: 'patternProperties',
+      additional_properties: 'additionalProperties',
+      property_names: 'propertyNames',
+      dependent_required: 'dependentRequired',
+      dependent_schemas: 'dependentSchemas',
+      all_of: 'allOf',
+      any_of: 'anyOf',
+      one_of: 'oneOf',
+      not: 'not',
+      if_then_else: 'if',
+      discriminator: 'discriminator',
+      ref: '$ref',
+      dynamic_ref: '$dynamicRef',
+      dynamic_scope: '$dynamicAnchor',
+      unevaluated_properties: 'unevaluatedProperties',
+      unevaluated_items: 'unevaluatedItems',
+      format: 'format'
+    }.freeze
+  end
+
+  Instruction = Struct.new(:op, :payload, :keyword_location, :schema, keyword_init: true) do
+    def keyword
+      Instructions::KEYWORDS.fetch(op, op.to_s)
+    end
+  end
+end

data/lib/senko/compiler/optimizer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Senko
+  class Compiler
+    class Optimizer
+      def optimize(instructions, seen = {})
+        return instructions if seen[instructions.object_id]
+
+        seen[instructions.object_id] = true
+        begin
+          instructions.flat_map do |instruction|
+            optimized = optimize_instruction(instruction, seen)
+            next [] if removable?(optimized)
+
+            inlineable?(optimized) ? optimized.payload[:schemas].first : [optimized]
+          end
+        ensure
+          seen.delete(instructions.object_id)
+        end
+      end
+
+      private
+
+      def optimize_instruction(instruction, seen)
+        payload = optimize_payload(instruction.payload, seen)
+        instruction.class.new(
+          op: instruction.op,
+          payload: payload,
+          keyword_location: instruction.keyword_location,
+          schema: instruction.schema
+        )
+      end
+
+      def optimize_payload(payload, seen)
+        return payload unless payload.is_a?(Hash)
+
+        payload.transform_values do |value|
+          case value
+          when Array
+            optimize_array_value(value, seen)
+          when Hash
+            optimize_hash_value(value, seen)
+          else
+            value
+          end
+        end
+      end
+
+      def optimize_array_value(value, seen)
+        if value.all?(Instruction)
+          optimize(value, seen)
+        elsif value.all? { |item| instruction_array?(item) }
+          value.map { |item| optimize(item, seen) }
+        else
+          value
+        end
+      end
+
+      def optimize_hash_value(value, seen)
+        value.transform_values do |child|
+          instruction_array?(child) ? optimize(child, seen) : child
+        end
+      end
+
+      def instruction_array?(value)
+        value.is_a?(Array) && value.all?(Instruction)
+      end
+
+      def removable?(instruction)
+        (instruction.op == :min_length && instruction.payload[:limit].zero?) ||
+          (instruction.op == :min_items && instruction.payload[:limit].zero?) ||
+          (instruction.op == :min_properties && instruction.payload[:limit].zero?)
+      end
+
+      def inlineable?(_instruction)
+        false
+      end
+    end
+  end
+end