apigen 0.0.6 → 0.0.7

data/lib/apigen/models/oneof_type.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../util'
+
+module Apigen
+  ##
+  # OneofType represents a union type, aka "either or".
+  class OneofType
+    ##
+    # The discriminator tells us which property defines the type of the object.
+    #
+    # Setting a discriminator is optional, but recommended.
+    attribute_setter_getter :discriminator
+    attr_reader :mapping
+
+    def initialize
+      @discriminator = nil
+      @mapping = {}
+    end
+
+    def map(mapping)
+      @mapping = mapping
+    end
+
+    def validate(model_registry)
+      @mapping.each do |key, value|
+        raise 'Mapping keys must be model names (use symbols).' unless key.is_a? Symbol
+        raise 'Mapping values must be strings.' unless value.is_a? String
+        raise "No such model :#{key} for oneof mapping." unless model_registry.models.key? key
+      end
+    end
+  end
+end

data/lib/apigen/models/primary_type.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Apigen
+  ##
+  # PrimaryType represents a primary type such as a string or an integer.
+  class PrimaryType
+    PRIMARY_TYPES = Set.new %i[string int32 bool void]
+
+    def self.primary?(shape)
+      PRIMARY_TYPES.include? shape
+    end
+
+    attr_reader :shape
+
+    def initialize(shape)
+      @shape = shape
+    end
+
+    def validate(_model_registry)
+      raise "Unsupported primary type :#{@shape}." unless self.class.primary?(@shape)
+    end
+
+    def ==(other)
+      other.is_a?(PrimaryType) && other.shape == shape
+    end
+
+    def to_s
+      @shape.to_s
+    end
+  end
+end

data/lib/apigen/models/reference_type.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Apigen
+  ##
+  # ReferenceType represents a reference to a model.
+  class ReferenceType
+    attr_reader :model_name
+
+    def initialize(model_name)
+      @model_name = model_name
+    end
+
+    def validate(model_registry)
+      raise "Model :#{@model_name} is not defined." unless model_registry.models.key? @model_name
+    end
+
+    def ==(other)
+      other.is_a?(ReferenceType) && other.model_name == model_name
+    end
+
+    def to_s
+      @model_name.to_s
+    end
+  end
+end

data/lib/apigen/models/registry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative './model'
+
+module Apigen
+  ##
+  # ModelRegistry is where all model definitions are stored.
+  class ModelRegistry
+    attr_reader :models
+
+    def initialize
+      @models = {}
+    end
+
+    def model(name, &block)
+      raise "Model :#{name} is declared twice." if @models.key? name
+      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)
+      type.validate self
+    end
+
+    def to_s
+      @models.map do |key, model|
+        "#{key}: #{model}"
+      end.join "\n"
+    end
+  end
+end

data/lib/apigen/rest.rb

@@ -1,271 +1,3 @@
 # frozen_string_literal: true
 
-require_relative './model'
-require_relative './util'
-
-PATH_PARAMETER_REGEX = /\{(\w+)\}/
-
-module Apigen
-  ##
-  # Rest contains what you need to declare a REST-ish API.
-  module Rest
-    ##
-    # Declares an API.
-    def self.api(&block)
-      api = Api.new
-      api.instance_eval(&block)
-      api.validate
-      api
-    end
-
-    ##
-    # Api is a self-contained definition of a REST API, includings its endpoints and data types.
-    class Api
-      attr_reader :endpoints
-      attribute_setter_getter :description
-
-      def initialize
-        @description = ''
-        @endpoints = []
-        @model_registry = Apigen::ModelRegistry.new
-      end
-
-      ##
-      # Declares a specific endpoint.
-      def endpoint(name, &block)
-        endpoint = Endpoint.new name
-        @endpoints << endpoint
-        endpoint.instance_eval(&block)
-      end
-
-      ##
-      # Declares a data model.
-      def model(name, &block)
-        @model_registry.model name, &block
-      end
-
-      def models
-        @model_registry.models
-      end
-
-      def validate
-        @model_registry.validate
-        @endpoints.each do |e|
-          e.validate @model_registry
-        end
-      end
-
-      def to_s
-        repr = "Endpoints:\n\n"
-        repr += @endpoints.map(&:to_s).join "\n"
-        repr += "\n\nTypes:\n\n"
-        repr += @model_registry.to_s
-        repr
-      end
-    end
-
-    ##
-    # Endpoint is a definition of a specific endpoint in the API, e.g. /users with GET method.
-    class Endpoint
-      attribute_setter_getter :name
-      attribute_setter_getter :description
-      attr_reader :outputs
-      attr_reader :path_parameters
-      attr_reader :query_parameters
-
-      def initialize(name)
-        @name = name
-        @method = nil
-        @path = nil
-        @path_parameters = Apigen::ObjectType.new
-        @query_parameters = Apigen::ObjectType.new
-        @input = nil
-        @outputs = []
-        @description = nil
-      end
-
-      #
-      # Declares the HTTP method.
-      def method(method = nil)
-        return @method unless method
-        case method
-        when :get, :post, :put, :delete
-          @method = method
-        else
-          raise "Unknown HTTP method :#{method}."
-        end
-      end
-
-      #
-      # Declares the endpoint path relative to the host.
-      def path(path = nil, &block)
-        return @path unless path
-        @path = path
-        if PATH_PARAMETER_REGEX.match path
-          set_path_parameters(path, &block)
-        elsif block_given?
-          raise 'A path block was provided but no URL parameter was found.'
-        end
-      end
-
-      #
-      # Declares query parameters.
-      def query(&block)
-        raise 'A block must be passed to define query fields.' unless block_given?
-        @query_parameters.instance_eval(&block)
-      end
-
-      ##
-      # Declares the input type of an endpoint.
-      def input(&block)
-        return @input unless block_given?
-        @input = Input.new
-        @input.instance_eval(&block)
-      end
-
-      ##
-      # Declares the output of an endpoint for a given status code.
-      def output(name, &block)
-        output = Output.new name
-        @outputs << output
-        output.instance_eval(&block)
-        output
-      end
-
-      def validate(model_registry)
-        validate_properties
-        validate_input(model_registry)
-        validate_path_parameters(model_registry)
-        validate_outputs(model_registry)
-      end
-
-      def to_s
-        repr = "#{@name}: #{@input}"
-        @outputs.each do |output|
-          repr += "\n-> #{output}"
-        end
-        repr
-      end
-
-      private
-
-      def set_path_parameters(path, &block)
-        block = {} unless block_given?
-        @path_parameters.instance_eval(&block)
-        expected_parameters = path.scan(PATH_PARAMETER_REGEX).map { |parameter, _| parameter.to_sym }
-        ensure_parameters_all_defined(expected_parameters)
-      end
-
-      def ensure_parameters_all_defined(expected_parameters)
-        expected_parameters.each do |parameter|
-          raise "Path parameter :#{parameter} in path #{@path} is not defined." unless @path_parameters.properties.key? parameter
-        end
-        @path_parameters.properties.each do |parameter, _type|
-          raise "Parameter :#{parameter} does not appear in path #{@path}." unless expected_parameters.include? parameter
-        end
-      end
-
-      def validate_properties
-        raise 'One of the endpoints is missing a name.' unless @name
-        raise "Use `method :get/post/put/delete` to set an HTTP method for :#{@name}." unless @method
-        raise "Use `path \"/some/path\"` to assign a path to :#{@name}." unless @path
-      end
-
-      def validate_input(model_registry)
-        case @method
-        when :put, :post
-          raise "Use `input { type :typename }` to assign an input type to :#{@name}." unless @input
-          @input.validate(model_registry)
-        when :get
-          raise "Endpoint :#{@name} with method GET cannot accept an input payload." if @input
-        when :delete
-          raise "Endpoint :#{@name} with method DELETE cannot accept an input payload." if @input
-        end
-      end
-
-      def validate_path_parameters(model_registry)
-        @path_parameters.validate model_registry
-      end
-
-      def validate_outputs(model_registry)
-        raise "Endpoint :#{@name} does not declare any outputs" if @outputs.empty?
-        @outputs.each do |output|
-          output.validate model_registry
-        end
-      end
-    end
-
-    ##
-    # Input is the request body expected by an API endpoint.
-    class Input
-      attribute_setter_getter :description
-      attribute_setter_getter :example
-
-      def initialize
-        @type = nil
-        @description = nil
-      end
-
-      ##
-      # Declares the input type.
-      def type(type = nil, &block)
-        return @type unless type
-        @type = Apigen::Model.type type, &block
-      end
-
-      def validate(model_registry)
-        validate_properties
-        model_registry.check_type @type
-      end
-
-      def to_s
-        @type.to_s
-      end
-
-      private
-
-      def validate_properties
-        raise 'Use `type :typename` to assign a type to the input.' unless @type
-      end
-    end
-
-    ##
-    # Output is the response type associated with a specific status code for an API endpoint.
-    class Output
-      attribute_setter_getter :status
-      attribute_setter_getter :description
-      attribute_setter_getter :example
-
-      def initialize(name)
-        @name = name
-        @status = nil
-        @type = nil
-        @description = nil
-      end
-
-      ##
-      # Declares the output type.
-      def type(type = nil, &block)
-        return @type unless type
-        @type = Apigen::Model.type type, &block
-      end
-
-      def validate(model_registry)
-        validate_properties
-        model_registry.check_type @type
-      end
-
-      def to_s
-        "#{@name} #{@status} #{@type}"
-      end
-
-      private
-
-      def validate_properties
-        raise 'One of the outputs is missing a name.' unless @name
-        raise "Use `status [code]` to assign a status code to :#{@name}." unless @status
-        raise "Use `type :typename` to assign a type to :#{@name}." unless @type
-      end
-    end
-  end
-end
+require_relative './rest/api'

data/lib/apigen/rest/api.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../util'
+require_relative './endpoint'
+require_relative '../models/registry'
+
+module Apigen
+  ##
+  # Rest contains what you need to declare a REST-ish API.
+  module Rest
+    ##
+    # Declares an API.
+    def self.api(&block)
+      api = Api.new
+      raise 'You must a block when calling `api`.' unless block_given?
+      api.instance_eval(&block)
+      api.validate
+      api
+    end
+
+    ##
+    # Api is a self-contained definition of a REST API, includings its endpoints and data types.
+    class Api
+      attr_reader :endpoints
+      attribute_setter_getter :description
+
+      def initialize
+        @description = ''
+        @endpoints = []
+        @model_registry = Apigen::ModelRegistry.new
+      end
+
+      ##
+      # Declares a specific endpoint.
+      def endpoint(name, &block)
+        raise "Endpoint :#{name} is declared twice." if @endpoints.find { |e| e.name == name }
+        endpoint = Endpoint.new name
+        @endpoints << endpoint
+        raise 'You must pass a block when calling `endpoint`.' unless block_given?
+        endpoint.instance_eval(&block)
+      end
+
+      ##
+      # Declares a data model.
+      def model(name, &block)
+        @model_registry.model name, &block
+      end
+
+      def models
+        @model_registry.models
+      end
+
+      def validate
+        @model_registry.validate
+        @endpoints.each do |e|
+          e.validate @model_registry
+        end
+      end
+
+      def migrate(*migration_classes)
+        migration_classes.each { |klass| klass.new(self).up }
+      end
+
+      def to_s
+        repr = "Endpoints:\n\n"
+        repr += @endpoints.map(&:to_s).join "\n"
+        repr += "\nTypes:\n\n"
+        repr += @model_registry.to_s
+        repr
+      end
+    end
+  end
+end