apigen 0.0.6 → 0.0.7

data/lib/apigen/model.rb

@@ -1,236 +1,3 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative './util'
-
-module Apigen
-  PRIMARY_TYPES = Set.new %i[string int32 bool void]
-
-  ##
-  # ModelRegistry is where all model definitions are stored.
-  class ModelRegistry
-    attr_reader :models
-
-    def initialize
-      @models = {}
-    end
-
-    def model(name, &block)
-      model = Apigen::Model.new name
-      raise 'You must pass a block when calling `model`.' unless block_given?
-      model.instance_eval(&block)
-      @models[model.name] = model
-    end
-
-    def validate
-      @models.each do |_key, model|
-        model.validate self
-      end
-    end
-
-    def check_type(type)
-      if type.is_a? Symbol
-        raise "Unknown type :#{type}." unless @models.key?(type) || PRIMARY_TYPES.include?(type)
-      elsif type.is_a?(ObjectType) || type.is_a?(ArrayType) || type.is_a?(OptionalType)
-        type.validate self
-      else
-        raise "Cannot process type #{type.class.name}"
-      end
-    end
-
-    def to_s
-      @models.map do |key, model|
-        "#{key}: #{model}"
-      end.join "\n"
-    end
-  end
-
-  ##
-  # Model represents a data model with a specific name, e.g. "User" with an object type.
-  class Model
-    attr_reader :name
-    attribute_setter_getter :description
-    attribute_setter_getter :example
-
-    def initialize(name)
-      @name = name
-      @type = nil
-      @description = nil
-    end
-
-    def type(shape = nil, &block)
-      return @type unless shape
-      @type = Model.type shape, &block
-    end
-
-    def self.type(shape, &block)
-      if shape.to_s.end_with? '?'
-        shape = shape[0..-2].to_sym
-        optional = true
-      else
-        optional = false
-      end
-      case shape
-      when :object
-        object = ObjectType.new
-        object.instance_eval(&block)
-        type = object
-      when :array
-        array = ArrayType.new
-        array.instance_eval(&block)
-        type = array
-      when :optional
-        optional = OptionalType.new
-        optional.instance_eval(&block)
-        type = optional
-      else
-        type = shape
-      end
-      optional ? OptionalType.new(type) : type
-    end
-
-    def validate(model_registry)
-      raise 'One of the models is missing a name.' unless @name
-      raise "Use `type :model_type [block]` to assign a type to :#{@name}." unless @type
-      model_registry.check_type @type
-    end
-
-    def to_s
-      @type.to_s
-    end
-  end
-
-  ##
-  # ObjectType represents an object type, with specific fields.
-  class ObjectType
-    attr_reader :properties
-
-    def initialize
-      @properties = {}
-    end
-
-    # rubocop:disable Style/MethodMissingSuper
-    def method_missing(field_name, *args, &block)
-      raise "Field :#{field_name} is defined multiple times." if @properties.key? field_name
-      field_type = args[0]
-      field_description = args[1]
-      block_called = false
-      if block_given?
-        block_wrapper = lambda do
-          block_called = true
-          yield
-        end
-      end
-      property = ObjectProperty.new(
-        Apigen::Model.type(field_type, &block_wrapper),
-        field_description
-      )
-      property.instance_eval(&block) if block_given? && !block_called
-      @properties[field_name] = property
-    end
-    # rubocop:enable Style/MethodMissingSuper
-
-    def respond_to_missing?(_method_name, _include_private = false)
-      true
-    end
-
-    def validate(model_registry)
-      @properties.each do |_key, property|
-        model_registry.check_type property.type
-      end
-    end
-
-    def to_s
-      repr ''
-    end
-
-    def repr(indent)
-      repr = '{'
-      @properties.each do |key, property|
-        type_repr = if property.type.respond_to? :repr
-                      property.type.repr(indent + '  ')
-                    else
-                      property.type.to_s
-                    end
-        repr += "\n#{indent}  #{key}: #{type_repr}"
-      end
-      repr += "\n#{indent}}"
-      repr
-    end
-  end
-
-  ##
-  # ObjectProperty is a specific property in an ObjectType.
-  class ObjectProperty
-    attr_reader :type
-    attribute_setter_getter :description
-    attribute_setter_getter :example
-
-    def initialize(type, description = nil)
-      @type = type
-      @description = description
-    end
-  end
-
-  ##
-  # ArrayType represents an array type, with a given item type.
-  class ArrayType
-    def initialize(type = nil)
-      @type = type
-    end
-
-    def type(item_type = nil, &block)
-      return @type unless item_type
-      @type = Apigen::Model.type item_type, &block
-    end
-
-    def validate(model_registry)
-      raise 'Use `type [typename]` to specify the type of types in an array.' unless @type
-      model_registry.check_type @type
-    end
-
-    def to_s
-      repr ''
-    end
-
-    def repr(indent)
-      type_repr = if @type.respond_to? :repr
-                    @type.repr indent
-                  else
-                    @type.to_s
-                  end
-      "ArrayType<#{type_repr}>"
-    end
-  end
-
-  ##
-  # OptionalType represents a type whose value may be absent.
-  class OptionalType
-    def initialize(type = nil)
-      @type = type
-    end
-
-    def type(item_type = nil, &block)
-      return @type unless item_type
-      @type = Apigen::Model.type item_type, &block
-    end
-
-    def validate(model_registry)
-      raise 'Use `type [typename]` to specify an optional type.' unless @type
-      model_registry.check_type @type
-    end
-
-    def to_s
-      repr ''
-    end
-
-    def repr(indent)
-      type_repr = if @type.respond_to? :repr
-                    @type.repr indent
-                  else
-                    @type.to_s
-                  end
-      "OptionalType<#{type_repr}>"
-    end
-  end
-end
+require_relative './models/model'

data/lib/apigen/models/array_type.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Apigen
+  ##
+  # ArrayType represents an array type, with a given item type.
+  class ArrayType
+    def initialize(type = nil)
+      @type = type
+    end
+
+    def type(item_type = nil, &block)
+      return @type unless item_type
+      @type = Apigen::Model.type item_type, &block
+    end
+
+    def validate(model_registry)
+      raise 'Use `type [typename]` to specify the type of items in an array.' unless @type
+      model_registry.check_type @type
+    end
+
+    def to_s
+      repr ''
+    end
+
+    def repr(indent)
+      type_repr = if @type.respond_to? :repr
+                    @type.repr indent
+                  else
+                    @type.to_s
+                  end
+      "ArrayType<#{type_repr}>"
+    end
+  end
+end

data/lib/apigen/models/enum_type.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../util'
+
+module Apigen
+  ##
+  # EnumType represents an enum (a type that can be one of several constants).
+  class EnumType
+    attr_reader :values
+
+    def initialize
+      @values = []
+    end
+
+    def value(val)
+      @values << val
+    end
+
+    def validate(_model_registry)
+      @values.each do |val|
+        raise 'Enums only support string values' unless val.is_a? String
+      end
+    end
+  end
+end

data/lib/apigen/models/model.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../util'
+require_relative './array_type'
+require_relative './enum_type'
+require_relative './object_type'
+require_relative './oneof_type'
+require_relative './primary_type'
+require_relative './reference_type'
+require_relative './registry'
+
+module Apigen
+  ##
+  # Model represents a data model with a specific name, e.g. "User" with an object type.
+  class Model
+    attr_reader :name
+    attribute_setter_getter :description
+    attribute_setter_getter :example
+
+    def initialize(name)
+      @name = name
+      @type = nil
+      @description = nil
+    end
+
+    def type(shape = nil, &block)
+      return @type unless shape
+      @type = Model.type shape, &block
+    end
+
+    def self.type(shape, &block)
+      case shape
+      when :object
+        object = ObjectType.new
+        object.instance_eval(&block)
+        object
+      when :array
+        array = ArrayType.new
+        array.instance_eval(&block)
+        array
+      when :oneof
+        oneof = OneofType.new
+        oneof.instance_eval(&block)
+        oneof
+      when :enum
+        enum = EnumType.new
+        enum.instance_eval(&block)
+        enum
+      else
+        raise "A block should not be provided with :#{shape}." if block_given?
+        primary_or_reference_type(shape)
+      end
+    end
+
+    private_class_method def self.primary_or_reference_type(shape)
+      if PrimaryType.primary?(shape)
+        PrimaryType.new(shape)
+      else
+        ReferenceType.new(shape)
+      end
+    end
+
+    def validate(model_registry)
+      raise 'One of the models is missing a name.' unless @name
+      raise "Use `type :model_type [block]` to assign a type to :#{@name}." unless @type
+      model_registry.check_type @type
+    end
+
+    def update_object_properties(&block)
+      raise "#{@name} is not an object type" unless @type.is_a? ObjectType
+      @type.instance_eval(&block)
+    end
+
+    def to_s
+      @type.to_s
+    end
+  end
+end

data/lib/apigen/models/object_property.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../util'
+
+module Apigen
+  ##
+  # ObjectProperty is a specific property in an ObjectType.
+  class ObjectProperty
+    attr_reader :type
+    attr_writer :required
+    attribute_setter_getter :description
+    attribute_setter_getter :example
+
+    def initialize(type, description = nil, example = nil)
+      @type = type
+      @description = description
+      @example = example
+      @required = true
+    end
+
+    def required(required)
+      @required = required
+      self
+    end
+
+    def required?
+      @required
+    end
+
+    def explain(&block)
+      raise 'You must pass a block to `explain`.' unless block_given?
+      instance_eval(&block)
+    end
+
+    def ==(other)
+      other.is_a?(ObjectProperty) && type == other.type && required? == other.required? && description == other.description && example == other.example
+    end
+  end
+end

data/lib/apigen/models/object_type.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative '../util'
+require_relative './object_property'
+
+module Apigen
+  ##
+  # ObjectType represents an object type, with specific properties.
+  class ObjectType
+    attr_reader :properties
+
+    def initialize
+      @properties = {}
+    end
+
+    def add(&block)
+      instance_eval(&block)
+    end
+
+    def remove(*property_names)
+      property_names.each do |property_name|
+        raise "Cannot remove nonexistent property :#{property_name}." unless @properties.delete(property_name)
+      end
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    def method_missing(property_name, property_shape, &block)
+      raise "Property :#{property_name} is defined multiple times." if @properties.key? property_name
+      raise "Property type must be a symbol, found #{property_shape}." unless property_shape.is_a? Symbol
+      if property_shape.to_s.end_with? '?'
+        property_shape = property_shape[0..-2].to_sym
+        required = false
+      else
+        required = true
+      end
+      property = ObjectProperty.new(Apigen::Model.type(property_shape, &block))
+      property.required = required
+      @properties[property_name] = property
+    end
+    # rubocop:enable Style/MethodMissingSuper
+
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+
+    def validate(model_registry)
+      @properties.each do |_key, property|
+        model_registry.check_type property.type
+      end
+    end
+
+    def to_s
+      repr ''
+    end
+
+    def repr(indent)
+      repr = '{'
+      @properties.each do |key, property|
+        repr += "\n#{indent}  #{property_repr(indent, key, property)}"
+      end
+      repr += "\n#{indent}}"
+      repr
+    end
+
+    private
+
+    def property_repr(indent, key, property)
+      type_repr = if property.type.respond_to? :repr
+                    property.type.repr(indent + '  ')
+                  else
+                    property.type.to_s
+                  end
+      type_repr += '?' unless property.required?
+      "#{key}: #{type_repr}"
+    end
+  end
+end