tsjson 1.0.0

data/lib/types/enum.rb

@@ -0,0 +1,47 @@
+module TSJSON
+  class Enum < Base
+    def initialize(members = {})
+      super()
+
+      @members = members
+      @members.each { |name, type| validate_type!(type) }
+    end
+
+    def member(name)
+      m = @members[name]
+      raise "Can't access property #{name} of #{self.class.name}" unless m
+
+      m
+    end
+    alias property member
+
+    def push_type(type)
+      validate_type!(type)
+      return self if types.include?(type)
+      return Enum.new(@types.dup.push(type))
+    end
+
+    def types
+      @types ||= @members.values
+    end
+
+    def has?(type)
+      types.include?(type)
+    end
+
+    def validate_type!(type)
+      unless type.is_a?(Literal)
+        raise "Enum can contain only literal values received #{type.class}"
+      end
+    end
+
+    def validate(value)
+      types.each { |type| return true if type.valid?(value) }
+
+      raise LiteralUnionValidationError.new(
+              expected_values: types.map(&:value),
+              received_value: value
+            )
+    end
+  end
+end

data/lib/types/float.rb

@@ -0,0 +1,17 @@
+require_relative './scalar.rb'
+
+module TSJSON
+  class FloatType < ScalarType
+    def initialize
+      super('Float')
+    end
+
+    def validate(value)
+      super(value) unless value.is_a?(::Numeric)
+
+      true
+    end
+  end
+
+  TSJSONFloat = FloatType.new
+end

data/lib/types/index.rb

@@ -0,0 +1,27 @@
+require_relative '../errors/index.rb'
+
+#
+
+require_relative './string.rb'
+require_relative './int.rb'
+require_relative './float.rb'
+require_relative './boolean.rb'
+require_relative './null.rb'
+require_relative './any.rb'
+
+#
+
+require_relative './literal.rb'
+require_relative './scalar_union.rb'
+require_relative './literal_union.rb'
+require_relative './list.rb'
+require_relative './object.rb'
+
+#
+
+require_relative './enum.rb'
+
+#
+
+require_relative './union.rb'
+require_relative './intersection.rb'

data/lib/types/int.rb

@@ -0,0 +1,17 @@
+require_relative './scalar.rb'
+
+module TSJSON
+  class IntType < ScalarType
+    def initialize
+      super('Int')
+    end
+
+    def validate(value)
+      super(value) unless value.is_a?(::Integer)
+
+      true
+    end
+  end
+
+  TSJSONInt = IntType.new
+end

data/lib/types/intersection.rb

@@ -0,0 +1,72 @@
+require_relative './merge.rb'
+
+module TSJSON
+  class Intersection < Merge
+    def normal_form
+      unless @normalized
+        @normalized =
+          @types.reduce(Intersection.new) do |buffer, type|
+            if type.is_a?(Merge)
+              buffer.intersect_normal(type.normal_form)
+            else
+              buffer.intersect_normal(type)
+            end
+          end
+      end
+      @normalized
+    end
+
+    def intersect_normal(other)
+      #   raise_if_not_composite(other)
+
+      if other.is_a?(Intersection)
+        Intersection.new(@types.dup.concat(other.types), true)
+      elsif other.is_a?(Union)
+        other.types.reduce(Union.new) do |u, t|
+          u.union_normal(intersect_normal(t))
+        end
+      else
+        Intersection.new(@types.dup.push(other), true)
+      end
+    end
+
+    def union_normal(other)
+      #   raise_if_not_composite(other)
+
+      Union.new([self, other], true)
+    end
+
+    def validate(object)
+      return normal_form.validate(object) unless @is_normal
+
+      merged_object.validate(object)
+    end
+
+    def fields
+      merged_object.fields
+    end
+
+    def to_s
+      @types.map(&:to_s).join(' & ')
+    end
+
+    def compile
+      return if @compiled
+      @compiled = true
+
+      return normal_form.compile unless @is_normal
+      merged_object
+    end
+
+    private
+
+    def merged_object
+      raise 'not a normal form' unless @is_normal
+
+      @merged_object ||=
+        ObjectType.new(
+          @types.reduce({}) { |obj, type| obj.merge(type.fields_map) }
+        )
+    end
+  end
+end

data/lib/types/list.rb

@@ -0,0 +1,33 @@
+module TSJSON
+  class List < Base
+    def initialize(type)
+      super()
+      @type = type
+    end
+
+    def of_type
+      @type
+    end
+
+    def validate(value)
+      unless value.is_a?(::Array)
+        raise ScalarValidationError.new(
+                expected_type: 'Array',
+                received_type: value.class.name,
+                received_value: value
+              )
+      end
+
+      errors = []
+      value.each_with_index do |item, index|
+        of_type.validate(item)
+      rescue ValidationError => e
+        errors.push({ index: index, error: e })
+      end
+
+      raise ListValidationError.new(errors: errors) if errors.length > 0
+
+      true
+    end
+  end
+end

data/lib/types/literal.rb

@@ -0,0 +1,25 @@
+module TSJSON
+  class Literal < Base
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def ==(other)
+      return value == other unless other.is_a?(self.class)
+
+      value == other.value
+    end
+
+    def validate(other)
+      unless @value == other
+        raise LiteralValidationError.new(
+                expected_value: @value, received_value: other
+              )
+      end
+
+      true
+    end
+  end
+end

data/lib/types/literal_union.rb

@@ -0,0 +1,48 @@
+module TSJSON
+  class LiteralUnion < Base
+    attr_reader :types
+
+    def initialize(types = [])
+      types.each { |t| validate_type!(t) }
+
+      @types = types
+    end
+
+    def push_type(type)
+      validate_type!(type)
+      return self if types.include?(type)
+      return LiteralUnion.new(@types.dup.push(type))
+    end
+
+    def has?(type)
+      @types.include?(type)
+    end
+
+    def size
+      @types.size
+    end
+
+    def validate_type!(type)
+      unless type.is_a?(Literal)
+        raise 'LiteralUnion may contain only Literal types'
+      end
+    end
+
+    def validate(value)
+      @types.each { |type| return true if type.valid?(value) }
+
+      raise LiteralUnionValidationError.new(
+              expected_values: @types.map(&:value),
+              received_value: value
+            )
+    end
+
+    def to_s
+      @types.map(&:to_s).join(' | ')
+    end
+
+    def to_json
+      @types.map(&:value)
+    end
+  end
+end

data/lib/types/merge.rb

@@ -0,0 +1,21 @@
+module TSJSON
+  class Merge < Base
+    attr_reader :types
+    attr_accessor :is_normal
+
+    def initialize(types = [], is_normal = false)
+      super()
+
+      types.each do |t|
+        unless t.is_a?(ObjectType) || t.is_a?(Union) || t.is_a?(Intersection)
+          raise "#{
+                  self.class.name
+                } may contain only ObjectType, Union or Intersection types"
+        end
+      end
+
+      @types = types
+      @is_normal = types.length == 0 || is_normal
+    end
+  end
+end

data/lib/types/null.rb

@@ -0,0 +1,17 @@
+require_relative './scalar.rb'
+
+module TSJSON
+  class NullType < ScalarType
+    def initialize
+      super('Null')
+    end
+
+    def validate(value)
+      super(value) unless value == nil
+
+      true
+    end
+  end
+
+  TSJSONNull = NullType.new
+end

data/lib/types/object.rb

@@ -0,0 +1,87 @@
+module TSJSON
+  class ObjectType < Base
+    def initialize(fields_map = nil, &block)
+      super()
+      @fields_map = fields_map&.transform_keys!(&:to_s)
+      @resolve_fields = block
+    end
+
+    def fields
+      @fields = fields_map.map { |k, v| v.merge({ name: k }) } unless @fields
+
+      @fields
+    end
+
+    def field(name)
+      f = fields_map.dig(name, :type)
+      raise "Can't access index #{name} of #{self.class.name}" unless f
+
+      f
+    end
+    alias index field
+
+    def fields_map
+      unless @fields_map
+        @fields_map = @resolve_fields.call&.transform_keys!(&:to_s)
+      end
+      @fields_map
+    end
+
+    def compile
+      return if @compiled
+      @compiled = true
+
+      fields.each { |f| f[:type].compile }
+    end
+
+    def validate(object)
+      unless object.is_a?(::Hash)
+        raise ScalarValidationError.new(
+                expected_type: 'Object',
+                received_type: object.class.name,
+                received_value: object
+              )
+      end
+
+      object = object&.transform_keys!(&:to_s)
+
+      keys = object.keys
+      errors = []
+
+      fields.each do |f|
+        name = f[:name]
+        type = f[:type]
+        optional = f[:optional]
+        value = object[name]
+
+        keys.delete(name)
+        has_field = object.key?(name)
+        next if optional && !has_field
+        raise RequiredFieldError.new if !optional && !has_field
+
+        type.validate(value)
+      rescue ValidationError => e
+        errors.push({ field: name, error: e })
+      end
+      keys.each do |name|
+        errors.push({ field: name, error: UnexpectedFieldError.new })
+      end
+
+      raise ObjectValidationError.new(errors: errors) if errors.length > 0
+
+      true
+    end
+
+    def to_s
+      "{\n#{
+        fields.map do |f|
+          name = f[:name]
+          type = f[:type].to_s
+          optional = f[:optional]
+
+          "  #{name}#{optional ? '?' : ''}: #{type}"
+        end.join("\n")
+      }\n}"
+    end
+  end
+end

data/lib/types/scalar.rb

@@ -0,0 +1,24 @@
+require_relative './base.rb'
+
+module TSJSON
+  class ScalarType < Base
+    attr_reader :name
+
+    def initialize(name)
+      super()
+      @name = name
+    end
+
+    def validate(value)
+      raise ScalarValidationError.new(
+              expected_type: @name,
+              received_type: value.class.name,
+              received_value: value
+            )
+    end
+
+    def to_s
+      @name
+    end
+  end
+end