tsjson 1.0.0

data/lib/language/source.rb

@@ -0,0 +1,109 @@
+module TSJSON
+  class Source
+    attr_accessor :body, :name, :locationOffset
+
+    def initialize(
+      body, name = 'TSJSON Source', locationOffset = { line: 1, column: 1 }
+    )
+      self.body = body
+      self.name = name
+      self.locationOffset = locationOffset
+    end
+
+    def self.print_location(location)
+      return(
+        print_source_location(
+          location.source,
+          Location.get_location(location.source, location.start)
+        )
+      )
+    end
+
+    def self.print_source_location(source, sourceLocation)
+      firstLineColumnOffset = source.locationOffset[:column] - 1
+      body = whitespace(firstLineColumnOffset) + source.body
+
+      lineIndex = sourceLocation[:line] - 1
+      lineOffset = source.locationOffset[:line] - 1
+      lineNum = sourceLocation[:line] + lineOffset
+
+      columnOffset = sourceLocation[:line] === 1 ? firstLineColumnOffset : 0
+      columnNum = sourceLocation[:column] + columnOffset
+      locationStr = "#{source.name}:#{lineNum}:#{columnNum}\n"
+
+      lines = body.split("\n", -1)
+      locationLine = lines[lineIndex]
+
+      # Special case for minified documents
+      if (locationLine.length > 120)
+        subLineIndex = Math.floor(columnNum / 80)
+        subLineColumnNum = columnNum % 80
+        subLines = []
+
+        i = 0
+        loop do
+          break unless i < locationLine.length
+          subLines.push(locationLine.slice(i, 80))
+          i += 80
+        end
+
+        return(
+          locationStr +
+            print_prefixed_lines(
+              [["#{lineNum}", subLines[0]]].concat(
+                subLines.slice(1, subLineIndex + 1).map do |subLine|
+                  ['', subLine]
+                end
+              ).concat(
+                [
+                  [' ', whitespace(subLineColumnNum - 1) + '^'],
+                  ['', subLines[subLineIndex + 1]]
+                ]
+              )
+            )
+        )
+      end
+
+      return(
+        locationStr +
+          print_prefixed_lines(
+            [
+              ["#{lineNum - 1}", lineIndex > 1 ? lines[lineIndex - 1] : nil],
+              ["#{lineNum}", locationLine],
+              ['', whitespace(columnNum - 1) + '^'],
+              ["#{lineNum + 1}", lines[lineIndex + 1]]
+            ]
+          )
+      )
+    end
+
+    def self.whitespace(len)
+      return Array.new(len + 1, '').join(' ')
+    end
+
+    def self.leftPad(len, str)
+      return whitespace(len - str.length) + str
+    end
+
+    def self.print_prefixed_lines(lines)
+      existingLines =
+        lines.filter do |line_arr|
+          _, line = line_arr
+          line != nil
+        end
+
+      padLen =
+        existingLines.map do |prefix_arr|
+          prefix = prefix_arr[0]
+          prefix.length
+        end.max
+
+      return(
+        existingLines.map do |line_arr|
+          prefix, line = line_arr
+          leftPad(padLen, prefix) + (line.empty? ? ' |' : ' | ' + line)
+        end.join("\n")
+      )
+    end
+  end
+end

data/lib/schema/schema.rb

@@ -0,0 +1,48 @@
+require_relative '../types/index.rb'
+require_relative './schema_builder'
+
+module TSJSON
+  class Schema
+    attr_reader :types_map
+
+    BUILT_IN_SCALARS = {
+      'string' => TSJSONString,
+      'int' => TSJSONInt,
+      'float' => TSJSONFloat,
+      'number' => TSJSONFloat,
+      'boolean' => TSJSONBoolean,
+      'any' => TSJSONAny,
+      'null' => TSJSONNull
+    }
+
+    def initialize
+      @types_map = {}
+    end
+
+    def type(name)
+      BUILT_IN_SCALARS[name] || @types_map[name]
+    end
+
+    def add_type(name, type)
+      raise 'duplicate type' if type(name)
+
+      @types_map[name] = type
+    end
+
+    def compile
+      @types_map.values.each(&:compile)
+    end
+
+    def self.build(source)
+      unless source.is_a?(Array) || source.is_a?(String)
+        raise 'Schema.build expects string or array of strings'
+      end
+      builder = SchemaBuilder.new
+      (source.is_a?(Array) ? source : [source]).each do |s|
+        builder.parse_source(s)
+      end
+      builder.schema.compile
+      return builder.schema
+    end
+  end
+end

data/lib/schema/schema_builder.rb

@@ -0,0 +1,148 @@
+require_relative '../language/parser/parser.rb'
+
+module TSJSON
+  class SchemaBuilder
+    attr_reader :schema
+
+    def initialize
+      @schema = Schema.new
+      @generics = {}
+    end
+
+    def add_generic(name, parameters_ast, type_ast)
+      check_duplicate_type(name)
+
+      parameters = parameters_ast.map { |p| { name: p[:name][:value] } }
+
+      @generics[name] = { parameters: parameters, type_ast: type_ast }
+    end
+
+    def add_type(name, type_ast)
+      check_duplicate_type(name)
+
+      @schema.add_type(name, type_definition(type_ast))
+    end
+
+    def check_duplicate_type(name)
+      if @schema.type(name) || @generics.key?(name)
+        raise "duplicate type #{name}"
+      end
+    end
+
+    def parse_source(source)
+      parser = Parser.new(source)
+      ast = parser.parse_document
+
+      ast[:definitions].each { |node| definition(node) }
+    end
+
+    def definition(node)
+      case node[:kind]
+      when AST::Kind::TypeAlias
+        name = node[:name][:value]
+        parameters = node[:parameters]
+        type_node = node[:definition]
+
+        if parameters.length > 0
+          add_generic(name, parameters, type_node)
+        else
+          add_type(name, type_node)
+        end
+        return
+      when AST::Kind::Enum
+        name = node[:name][:value]
+        members =
+          node[:members].reduce({}) do |acc, m|
+            acc.merge(
+              {
+                m[:name][:value] =>
+                  Literal.new(m.dig(:value, :value) || m.dig(:name, :value)) # use name as value if value is not defined
+              }
+            )
+          end
+        type = Enum.new(members)
+        @schema.add_type(name, type)
+        return
+      end
+
+      raise "Can't build definition. Kind: #{node[:kind]}"
+    end
+
+    def type_definition(node, scope = {})
+      case node[:kind]
+      when AST::Kind::TypeReference
+        return reference(node, scope)
+      when AST::Kind::ArrayType
+        return List.new(type_definition(node[:type], scope))
+      when AST::Kind::StringLiteral
+        return Literal.new(node[:value])
+      when AST::Kind::Int
+        return Literal.new(node[:value])
+      when AST::Kind::Float
+        return Literal.new(node[:value])
+      when AST::Kind::TypeLiteral
+        return(
+          ObjectType.new do
+            node[:properties].reduce({}) do |map, f|
+              map[f[:name][:value]] = {
+                type: type_definition(f[:type], scope),
+                optional: f[:optional]
+              }
+              map
+            end
+          end
+        )
+      when AST::Kind::IntersectionType
+        return(
+          Intersection.new(node[:types].map { |t| type_definition(t, scope) })
+        )
+      when AST::Kind::UnionType
+        types = node[:types].map { |t| type_definition(t, scope) }
+        t = types.first
+
+        if t.is_a?(ObjectType) || t.is_a?(Union) || t.is_a?(Intersection)
+          return Union.new(types)
+        elsif t.is_a?(ScalarType)
+          return ScalarUnion.new(types)
+        elsif t.is_a?(Literal)
+          return LiteralUnion.new(types)
+        end
+        raise "can't create union with type #{t.class.name}"
+      when AST::Kind::ParenthesizedType
+        return type_definition(node[:type], scope)
+      when AST::Kind::PropertyAccess
+        target = type_definition(node[:target], scope)
+        return target.property(node[:property][:value])
+      when AST::Kind::IndexAccess
+        target = type_definition(node[:target], scope)
+        return target.index(node[:index][:value])
+      end
+
+      raise "Can't build type definition. Kind: #{node[:kind]}"
+    end
+
+    def reference(node, scope)
+      name = node[:name][:value]
+
+      if type = scope[name] || @schema.type(name)
+        return type
+      elsif generic = @generics[name]
+        parameters = generic[:parameters]
+        args = node[:args]
+
+        new_scope =
+          generic[:parameters]
+            .each_with_index
+            .reduce(scope) do |memo, (param, idx)|
+              name = param[:name]
+              type_ast = args[idx]
+              raise "argument #{name} was not provided" if (!type_ast)
+
+              memo.merge({ name => type_definition(type_ast, scope) })
+            end
+        return type_definition(generic[:type_ast], new_scope)
+      end
+      raise "Type doesn't exist: #{name}" unless type
+    end
+  end
+end

data/lib/tsjson.rb

@@ -0,0 +1 @@
+require_relative './schema/schema.rb'

data/lib/types/any.rb

@@ -0,0 +1,15 @@
+require_relative './scalar.rb'
+
+module TSJSON
+  class AnyType < ScalarType
+    def initialize
+      super('Any')
+    end
+
+    def validate(value)
+      true
+    end
+  end
+
+  TSJSONAny = AnyType.new
+end

data/lib/types/base.rb

@@ -0,0 +1,19 @@
+module TSJSON
+  class Base
+    def valid?(value)
+      validate(value)
+    rescue ValidationError
+      false
+    end
+
+    def compile; end
+
+    def property(name)
+      raise "Can't access property #{name} of #{self.class.name}"
+    end
+
+    def index(name)
+      raise "Can't access index #{name} of #{self.class.name}"
+    end
+  end
+end

data/lib/types/boolean.rb

@@ -0,0 +1,17 @@
+require_relative './scalar.rb'
+
+module TSJSON
+  class BooleanType < ScalarType
+    def initialize
+      super('Boolean')
+    end
+
+    def validate(value)
+      super(value) unless value == true || value == false
+
+      true
+    end
+  end
+
+  TSJSONBoolean = BooleanType.new
+end

data/lib/types/discriminator_map.rb

@@ -0,0 +1,116 @@
+require_relative './literal.rb'
+
+module TSJSON
+  class DiscriminatorMap
+    attr_reader :discriminators
+
+    def initialize(types)
+      # Hash with discriminators.
+      # Key - name of the field
+      # Value - enum with all possible field values
+      discriminators = {}
+
+      # Hash of form H[field_name][field_value]=[...all types that matches field_name=field_value]
+      hash = {}
+
+      types.each do |t|
+        # for each field inside each type
+        t.fields.each do |f|
+          next unless f[:type].is_a?(Literal) || f[:type].is_a?(LiteralUnion) # only literal types may be used as discriminators
+
+          field_name = f[:name]
+
+          field_types = f[:type].is_a?(Literal) ? [f[:type]] : f[:type].types # iterate over all types of LiteralUnion
+          field_types.each do |field_type|
+            # create discriminator enums
+            if discriminators[field_name] == nil
+              discriminators[field_name] = LiteralUnion.new([field_type])
+            else
+              discriminators[field_name] =
+                discriminators[field_name].push_type(field_type)
+            end
+
+            # create array of types for each discriminator
+            if hash[field_name] == nil
+              hash[field_name] = { field_type.value => [t] }
+            else
+              if hash[field_name][field_type.value] == nil
+                hash[field_name][field_type.value] = [t]
+              else
+                hash[field_name][field_type.value].push(t)
+              end
+            end
+          end
+        end
+      end
+
+      # delete discriminators that appear in all types or in one only
+      hash.each do |field_name, values_hash|
+        if values_hash.values.length == 1 &&
+             values_hash.values[0].length == types.length
+          discriminators.delete(field_name)
+        end
+      end
+
+      # filter valid discriminators
+      hash =
+        hash.reject do |field_name, values_hash|
+          values_hash.values.length == 1 &&
+            values_hash.values[0].length == types.length
+        end.to_h
+
+      # check that all types are mapped
+      mapped_types = hash.values.map(&:values).flatten.uniq
+      if (mapped_types.length < types.length)
+        raise NotEnoughDiscriminators.new(types: types)
+      end
+
+      # replace array of types with single type or nested map
+      @hash =
+        hash.transform_values do |values_hash|
+          values_hash.transform_values do |types|
+            types.length == 1 ? types.first : DiscriminatorMap.new(types)
+          end
+        end
+
+      # create discriminators array sorted by appearance count
+      @discriminators =
+        discriminators.map { |k, v| { field: k, value: v } }.sort do |a, b|
+          b[:value].size <=> a[:value].size
+        end
+    end
+
+    def validate(object)
+      object = object&.transform_keys!(&:to_s)
+
+      discriminators.each do |discriminator|
+        field = discriminator[:field]
+        expected_value = discriminator[:value]
+
+        value = object[field]
+        unless value.nil?
+          unless expected_value.has?(value)
+            raise UnexpectedValueError.new(
+                    field: field,
+                    expected_values: expected_value.to_json,
+                    received: value
+                  )
+          end
+
+          return @hash[field][value].validate(object)
+        end
+      end
+
+      raise CantDistinguishTypeError.new(
+              discriminators:
+                discriminators.map { |d|
+                  { field: d[:field], values: d[:value].to_json }
+                }
+            )
+    end
+
+    def [](value)
+      @hash[value]
+    end
+  end
+end