eazypi 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b60b4097cbd524ad683d3bf4c25158620e491a0638649397da289fc4d63d21e1
-  data.tar.gz: a18fa4781d32592d1dc933d1923dfc389237d04ae02a067420c364cd35c8772c
+  metadata.gz: bfe47c3c3c7c8c3ac25c0d67311957fb2672599ea81f48e6247f82b9fae6710b
+  data.tar.gz: 436ec6c096a12482add4ac1a0245b4c555e254fd3be329ba9549e6b1422a1154
 SHA512:
-  metadata.gz: a96a3e253fea3076ba0953c166b9d31e295160c8c9ab34fbb0e72393ed1bfc647c39d7b9f2e98457c3f7c66b3ddc240cfb27aea0ca0fd25468cb51f41db8e5f7
-  data.tar.gz: '0832c28ce9c3120b63d3d40d3b59e5aea7701dc6b050ffe89c49ce54dbfdb5f74ce05091a0e587c5c2407df95b5a0e4b082cf23441400ce9505f1d6f6692a61a'
+  metadata.gz: f849fdc4f64b2471955dcf1b8517e6bd445d2285b646384c6081b6aa9ffb87d78e9be72a093c4731436ea6fd4340561a2b1aa89886cdb3e53f0c8007bfd704d6
+  data.tar.gz: 62e8ba592f52624d36bedba28e96f463956c6ae3cb16e1aa2d89acfc060459bc897d2034bdfa8e7423b7222104f0f4bca0acdbe4729358d821abc9d3cf5a91ce

data/CHANGELOG.md

@@ -1,3 +1,9 @@
-## [Unreleased]
+## [unreleased] 0.0.2
+
+- Allow boolean types
+- Collect schemas in the components and make Object schemas named
+- Automatically fill in servers if not explicitly given
+
+## [2024-02-22] 0.0.1
 
 - Initial release

data/eazypi.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/eazypi/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "eazypi"
+  spec.version = Eazypi::VERSION
+  spec.authors = ["Nathan Samson"]
+  spec.email = ["nathan@nathansamson.be"]
+  spec.license = "MIT"
+
+  spec.summary = "An opinionated framework to generate OpenAPI API's for Rails"
+  spec.homepage = "https://gitlab.com/nathansamson/eazypi/-/blob/main/README.md"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://gitlab.com/nathansamson/eazypi"
+  spec.metadata["changelog_uri"] = "https://gitlab.com/nathansamson/eazypi/-/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ petstore-example/ .git .gitlab-ci.yml appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "actionpack", "~> 7.0"
+  spec.add_dependency "activesupport", "~> 7.0"
+  spec.metadata["rubygems_mfa_required"] = "true"
+end

data/lib/eazypi/api.rb

@@ -26,6 +26,10 @@ module Eazypi
           paths[operation.path] ||= PathItem.new
 
           paths[operation.path].send(operation.method, operation)
+
+          operation.collect_components(
+            schemas: method(:reference_schema)
+          )
         end
       end
 
@@ -38,13 +42,19 @@ module Eazypi
       end
 
       def to_openapi_spec
+        to_openapi_spec_with_servers(servers)
+      end
+
+      def to_openapi_spec_with_servers(override_servers)
+        actual_servers = override_servers || servers
+
         {
           "openapi" => "3.0.3", # Future improvement allow different version
           "info" => info.to_openapi_spec,
           "paths" => paths.transform_keys do |path|
                        Operation.normalized_path(path)
                      end.transform_values(&:to_openapi_spec),
-          "servers" => servers.map(&:to_openapi_spec),
+          "servers" => actual_servers.map(&:to_openapi_spec),
           "components" => components.to_openapi_spec
         }
       end
@@ -71,22 +81,36 @@ module Eazypi
 
       private
 
+      def reference_schema(schema)
+        return unless schema.is_a?(Eazypi::Schema::Object) && !schema.object_name.nil?
+
+        reference = components.add_schema(schema.object_name, schema)
+        schema.reference!(reference)
+      end
+
       def prepare_controller_class
         ancestors[0].const_set("EazypiController", controller_class)
       end
 
-      def controller_class # rubocop:todo Metrics/MethodLength
+      def controller_class # rubocop:todo Metrics/MethodLength, Metrics/AbcSize
         @controller_class ||= begin
           api_instance = self
 
           klass = Class.new(ActionController::Base)
-          klass.define_method(:show) do
-            puts "HERER AI MA "
+          klass.define_method(:show) do # rubocop:todo Metrics/MethodLength
+            override_servers = if api_instance.servers.empty?
+                                 s = Server.new
+                                 s.url request.url.split("/")[0..-2].join("/") # Probably a better way to do this
+                                 [
+                                   s
+                                 ]
+                               end
 
             if params[:format] == "json"
-              render json: api_instance.to_openapi_spec
+              render json: api_instance.to_openapi_spec_with_servers(override_servers)
             elsif params[:format] == "yaml"
-              render plain: api_instance.to_openapi_spec.to_yaml, content_type: "text/yaml"
+              render plain: api_instance.to_openapi_spec_with_servers(override_servers).to_yaml,
+                     content_type: "text/yaml"
             else
               raise "#{params[:format]} not supported"
             end

data/lib/eazypi/api_controller.rb

@@ -5,6 +5,7 @@ module Eazypi
   module ApiController
     def self.included(base)
       base.instance_variable_set(:@operations, [])
+      base.include(InstanceMethods)
       base.extend(ClassMethods)
     end
 
@@ -53,5 +54,20 @@ module Eazypi
         controller_method_name
       end
     end
+
+    # Instance methods to be used in your own API controller
+    module InstanceMethods
+      def respond_with(object, status: :ok)
+        response_type = @current_operation.response_for_response_code(status)
+
+        response_object_type = response_type.object_type_for_content_type
+
+        if response_object_type.nil?
+          render json: nil, status: status
+        else
+          render json: response_type.object_type_for_content_type.new(object).to_json, status: status
+        end
+      end
+    end
   end
 end

data/lib/eazypi/components.rb

@@ -3,8 +3,20 @@
 module Eazypi
   # OpenAPI spec ComponentsObject
   class Components
+    def initialize
+      @schemas = {}
+    end
+
+    def add_schema(name, schema)
+      @schemas[name] = schema.dup # Make sure it never gets a reference
+
+      "#/components/schemas/#{name}"
+    end
+
     def to_openapi_spec
-      {}
+      {
+        "schemas" => @schemas.empty? ? nil : @schemas.transform_values(&:to_openapi_spec)
+      }.compact
     end
   end
 end

data/lib/eazypi/media_type.rb

@@ -7,6 +7,13 @@ module Eazypi
 
     spec_attribute :schema
 
+    def collect_components(schemas: nil, **kwargs)
+      return unless schema
+
+      schema.collect_components(schemas: schemas, **kwargs)
+      schemas&.call(schema)
+    end
+
     def to_openapi_spec
       {
         "schema" => schema.to_openapi_spec

data/lib/eazypi/operation.rb

@@ -44,11 +44,18 @@ module Eazypi
       @responses.add_response(status_code, &block)
     end
 
+    def response_for_response_code(response_code)
+      response_code = Rack::Utils::SYMBOL_TO_STATUS_CODE[response_code] if response_code.is_a?(Symbol)
+
+      @responses.response_for_response_code(response_code)
+    end
+
     def render(&block)
       @renderer = block
     end
 
     def call(controller)
+      controller.instance_variable_set(:@current_operation, self)
       controller.instance_exec(&@renderer)
     end
 
@@ -74,6 +81,11 @@ module Eazypi
       normalized_path
     end
 
+    def collect_components(**kwargs)
+      @request_body&.collect_components(**kwargs)
+      @responses&.collect_components(**kwargs)
+    end
+
     private
 
     PATH_REGEX = %r{/:[a-zA-Z0-9_-]+}

data/lib/eazypi/request_body.rb

@@ -20,6 +20,12 @@ module Eazypi
       end
     end
 
+    def collect_components(**kwargs)
+      @content&.each_value do |media_type|
+        media_type.collect_components(**kwargs)
+      end
+    end
+
     def to_openapi_spec
       {
         "description" => description,

data/lib/eazypi/response.rb

@@ -9,11 +9,14 @@ module Eazypi
 
     def initialize
       @content = {}
+      @object_type = {}
 
       super
     end
 
     def content(schema, content_type = "application/json")
+      return if schema.nil?
+
       media_type = MediaType.new
 
       media_type.load do
@@ -21,12 +24,23 @@ module Eazypi
       end
 
       @content[content_type] = media_type
+      @object_type[content_type] = schema
+    end
+
+    def object_type_for_content_type(content_type = "application/json")
+      @object_type[content_type]
+    end
+
+    def collect_components(**kwargs)
+      @content.each_value do |media_type|
+        media_type.collect_components(**kwargs)
+      end
     end
 
     def to_openapi_spec
       {
         "description" => description,
-        "content" => @content.transform_values(&:to_openapi_spec)
+        "content" => @content.empty? ? nil : @content.transform_values(&:to_openapi_spec)
       }.compact
     end
   end

data/lib/eazypi/responses.rb

@@ -14,6 +14,17 @@ module Eazypi
       @responses[status_code.to_s] = response
     end
 
+    def response_for_response_code(response_code)
+      # Future improvement could be partial match
+      @responses[response_code.to_s]
+    end
+
+    def collect_components(**kwargs)
+      @responses.each_value do |response|
+        response.collect_components(**kwargs)
+      end
+    end
+
     def to_openapi_spec
       @responses.transform_values(&:to_openapi_spec)
     end

data/lib/eazypi/schema/array.rb

@@ -10,6 +10,10 @@ module Eazypi
         @item_schema = item_schema
       end
 
+      def collect_components(schemas: nil, **_kwargs)
+        schemas&.call(@item_schema)
+      end
+
       def to_openapi_spec
         {
           "type" => "array",

data/lib/eazypi/schema/object.rb

@@ -4,9 +4,17 @@ module Eazypi
   module Schema
     # Object schema for Json
     class Object
-      def initialize
+      attr_reader :object_name
+
+      def initialize(object_name = nil)
         @properties = {}
         @required = []
+        @object_name = object_name
+        @reference = nil
+      end
+
+      def reference!(reference)
+        @reference = reference
       end
 
       def property(name, schema, required: false)
@@ -14,7 +22,16 @@ module Eazypi
         @required << name if required
       end
 
+      def collect_components(schemas: nil, **kwargs)
+        @properties.each_value do |property_schema|
+          property_schema.collect_components(schemas: schemas, **kwargs)
+          schemas&.call(property_schema)
+        end
+      end
+
       def to_openapi_spec
+        return { "$ref" => @reference } if @reference
+
         {
           "type" => "object",
           "required" => @required.empty? ? nil : @required,
@@ -26,7 +43,8 @@ module Eazypi
         return false unless other.is_a?(Object)
 
         other.instance_variable_get(:@properties) == @properties &&
-          other.instance_variable_get(:@required) == @required
+          other.instance_variable_get(:@required) == @required &&
+          other.object_name == object_name
       end
     end
   end

data/lib/eazypi/schema/primitive.rb

@@ -13,6 +13,8 @@ module Eazypi
         @format = format
       end
 
+      def collect_components(**_kwargs); end
+
       def to_openapi_spec
         {
           "type" => type,

data/lib/eazypi/schema.rb

@@ -3,8 +3,10 @@
 module Eazypi
   # JSON schema
   module Schema
-    def self.from_object(object) # rubocop:todo Metrics/MethodLength
-      if object.is_a?(::Array)
+    def self.from_object(object) # rubocop:todo Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+      if object == :boolean
+        Schema::Primitive.new(type: "boolean")
+      elsif object.is_a?(::Array)
         raise "Array needs to have one element" if object.length != 1
 
         Schema::Array.new(Schema.from_object(object[0]))

data/lib/eazypi/serializer.rb

@@ -9,12 +9,23 @@ module Eazypi
     class Attribute
       attr_reader :name, :type, :required
 
-      def initialize(name, type:, method_name:, required:)
+      def initialize(name, type:, required:, method:, method_name:)
         @name = name
         @type = type
+        @method = method
         @method_name = method_name
         @required = required
       end
+
+      def serialize(object)
+        if @method
+          @method.call(object)
+        elsif @method_name
+          object.send(@method_name)
+        else
+          object.send(@name)
+        end
+      end
     end
 
     def initialize(object)
@@ -23,17 +34,18 @@ module Eazypi
 
     def to_json(*_args)
       self.class.attributes.to_h do |attribute|
-        [attribute.name, @object.send(attribute.name)]
+        [attribute.name, attribute.serialize(@object)]
       end
     end
 
     included do
       @attributes = []
 
-      def self.attribute(attribute_name, type:, method_name: nil, required: false)
+      def self.attribute(attribute_name, type:, method: nil, method_name: nil, required: false)
         @attributes << Attribute.new(
           attribute_name,
           type: type,
+          method: method,
           method_name: method_name,
           required: required
         )
@@ -44,7 +56,7 @@ module Eazypi
       end
 
       def self.to_schema
-        schema = Schema::Object.new
+        schema = Schema::Object.new(name.split("::").last)
 
         @attributes.each do |attribute|
           schema.property attribute.name.to_s, Schema.from_object(attribute.type), required: attribute.required

data/lib/eazypi/server.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Eazypi
+  # OpenAPI spec ServerObject
+  class Server
+    include SpecObject
+
+    spec_attribute :url
+    spec_attribute :description
+
+    def to_openapi_spec
+      {
+        "url" => url,
+        "description" => description
+      }.compact
+    end
+  end
+end

data/lib/eazypi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Eazypi
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/eazypi.rb

@@ -22,4 +22,5 @@ require "eazypi/response"
 require "eazypi/responses"
 require "eazypi/schema"
 require "eazypi/serializer"
+require "eazypi/server"
 require "eazypi/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eazypi
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Nathan Samson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-22 00:00:00.000000000 Z
+date: 2024-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -50,6 +50,7 @@ files:
 - CHANGELOG.md
 - README.md
 - Rakefile
+- eazypi.gemspec
 - lib/eazypi.rb
 - lib/eazypi/api.rb
 - lib/eazypi/api_controller.rb
@@ -67,10 +68,12 @@ files:
 - lib/eazypi/schema/object.rb
 - lib/eazypi/schema/primitive.rb
 - lib/eazypi/serializer.rb
+- lib/eazypi/server.rb
 - lib/eazypi/spec_object.rb
 - lib/eazypi/version.rb
 homepage: https://gitlab.com/nathansamson/eazypi/-/blob/main/README.md
-licenses: []
+licenses:
+- MIT
 metadata:
   homepage_uri: https://gitlab.com/nathansamson/eazypi/-/blob/main/README.md
   source_code_uri: https://gitlab.com/nathansamson/eazypi
@@ -91,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: An opinionated framework to generate OpenAPI API's for Rails