tomyum 0.1.0.a

data/lib/tomyum/generators/open_api/property_generator.rb

@@ -0,0 +1,111 @@
+module Tomyum
+  module Generators
+    module OpenAPI
+      # Generate property based on Open API Spec
+      class PropertyGenerator < Tomyum::Attributes::Visitor
+        include Tomyum::Assertions
+
+        class << self
+          def visit(attr, options = {})
+            new.visit(attr, options)
+          end
+
+          alias_method :generate, :visit
+        end
+
+        def visit(attr, options = {})
+          attr = normalize_attribute(attr, options)
+
+          # handle case when attr is a Symbol (reference)
+          return attr unless attr.respond_to?(:native_type)
+
+          super
+        end
+
+        # catch-all
+        def visit_attribute(attr, options = {})
+          build(attr, options)
+        end
+
+        def visit_array(attr, options = {})
+          build(attr, options).tap do |property|
+            property[:items] = attr.of ? visit(attr.of, options) : {}
+          end
+        end
+
+        def visit_object(attr, options = {})
+          build(attr, options).tap do |property|
+            required = []
+            attr.attributes.values.each_with_object(property) do |attribute, object|
+
+              # Adds to required list
+              required << attribute.name if attribute.required
+
+              object[:properties] ||= {}
+              object[:properties][attribute.name] = visit(attribute, options) if attribute.serializable?
+            end
+
+            # additional options
+            property[:required] = required unless required.empty?
+          end
+        end
+
+        # Handle Schema
+        def visit_schema(attr, options)
+          return build_ref(attr.of) unless attr.expandable
+
+          # Schema#of may contains array of references
+          # e.g. of = [:user, :customer]
+          refs = Array(attr.of).map { |of| build_ref(of) }
+          refs << visit("string")
+
+          {
+            "oneOf": refs,
+          }
+        end
+
+        def normalize_attribute(object, options = {})
+          return build_ref(object, options)    if object.kind_of?(Symbol)
+          return object                        if object.respond_to?(:native_type)
+
+          # object is string (native types e.g. "integer", "boolean" etc)
+          Tomyum::Attributes.create(object.to_sym, object)
+        end
+
+        private
+
+        def build(attr, options = {})
+          assert_kind_of Tomyum::Attributes::Attribute, attr
+
+          # build base property
+          {
+            type: attr.native_type,
+          }.tap do |property|
+            property[:description]     = attr.description if attr.description.present?
+            property[:default]         = attr.default if attr.default
+            property[:enum]            = attr.in if attr.in
+            property[:nullable]        = attr.null if attr.null
+            property[:format]          = attr.format if attr.format
+            property[:pattern]         = build_pattern(attr.match) if attr.match
+            property["x-custom-schema"] = options[:schema] if options[:schema].present?
+          end
+        end
+
+        # create $ref
+        def build_ref(attr, options = {})
+          ref = options[:as] || attr
+
+          {
+            "$ref": "#/components/schemas/#{ref}",
+          }
+        end
+
+        def build_pattern(value)
+          return value.source if value.respond_to?(:source)
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/tomyum/generators.rb

@@ -0,0 +1,3 @@
+require_relative "generators/generator"
+require_relative "generators/open_api/generator"
+require_relative "generators/open_api/property_generator"

data/lib/tomyum/registry.rb

@@ -0,0 +1,75 @@
+module Tomyum
+  # A generic registry
+  #
+  # @example Create key/value pairs registry (Hash)
+  #   registry = Registry.new do |key, value|
+  #     { name: key, age: value }
+  #   end
+  #
+  #   # Register object
+  #   registry.register(:john, name: :john, age: 10)
+  #
+  #   # Retrieve object
+  #   registry.get(:john) # => { name: :john, age: 10 }
+  #
+  #   # Create new object
+  #   registry.create(:joe, 10) # => { name: joe, age: 10 }
+  class Registry
+    include Tomyum::Assertions
+
+    KeyError = Tomyum::Error.create("Object %s already exists")
+
+    # @param [Object] A collection of objects which has #name property
+    # @param &block A {Proc} that'll create new object
+    def initialize(objects = [], error: KeyError, &block)
+      assert_kind_of Proc, block
+
+      @objects = normalize objects
+      @factory = block
+      @error   = error
+    end
+
+    # Registers new object by id
+    #
+    # @param id [String] Unique name
+    # @param object [Object] Object to register
+    # @param override [Boolean] Overrides existing key if exists
+    def register(id, object, override: false)
+      if key?(id) && !override
+        raise @error, id
+      end
+
+      @objects[id.to_sym] = object
+    end
+
+    # Creates new object by using a {Proc} from #new
+    #
+    # @return [Object]
+    # @example
+    #   registry.create(:user, "john")
+    def create(id, *args, &block)
+      instance_exec(id, *args, block, &@factory)
+    end
+
+    # Retrieves registered Object by key
+    def get(id)
+      raise @error, id unless key?(id)
+
+      @objects[id.to_sym]
+    end
+
+    def key?(id)
+      @objects.key? id
+    end
+
+    def keys
+      @objects.keys
+    end
+
+    private
+
+    def normalize(objects = [])
+      (objects || []).each_with_object({}) { |object, target| target[object.name] = object }
+    end
+  end
+end

data/lib/tomyum/resolvable.rb

@@ -0,0 +1,11 @@
+module Tomyum
+  module Resolvable
+    ResolverRequired = Tomyum::Error.create("Resolver is required")
+
+    def resolver
+      raise ResolverRequired unless @resolver
+
+      @resolver
+    end
+  end
+end

data/lib/tomyum/resolver.rb

@@ -0,0 +1,99 @@
+module Tomyum
+  # Responsible for registering and looking up the schemas and endpoints
+  #
+  # @example Register via +:schemas+ and +:endpoints+ options
+  #   resolver = Resolver.new(schemas: [], endpoints: [])
+  #
+  # @example Register via +block+
+  #   resolver = Resolver.new do
+  #     schema :user do
+  #       string :username
+  #     end
+  #
+  #     schema :team do
+  #       string :name
+  #     end
+  #
+  #     endpoint "/users" do
+  #       string :username
+  #     end
+  #   end
+  #
+  # @example Manually register new schema/endpoint
+  #   resolver.schema(:user) do
+  #     string :username
+  #   end
+  #
+  #   resolver.endpoint("/teams") do
+  #     post :create
+  #   end
+  #
+  # @example Register an existing schema/endpoint
+  #   resolver.schemas.register(:user, user_schema)
+  #
+  class Resolver
+    Endpoint   = Tomyum::Endpoint
+    Attributes = Tomyum::Attributes
+
+    SchemaNotFound   = Tomyum::Error.create("Endpoint %s cannot be found")
+    EndpointNotFound = Tomyum::Error.create("Schema %s cannot be found")
+
+    def initialize(schemas: [], endpoints: [], schema_registry: nil, endpoint_registry: nil, &block)
+      @registries = {
+        schemas:   create_schema_registry(schemas, schema_registry),
+        endpoints: create_endpoint_registry(endpoints, endpoint_registry)
+      }
+
+      instance_exec(&block) if block_given?
+    end
+
+    def resolve(type, name)
+      @registries[type].get(name)
+    end
+
+    def register(type, name, args, &block)
+      @registries[type].create(name, **args, &block)
+    end
+
+    # Exposes schema registry
+    def schemas
+      @registries[:schemas]
+    end
+
+    # Exposes endpoint registry
+    def endpoints
+      @registries[:endpoints]
+    end
+
+    def schema(name, options = {}, &block)
+      return resolve(:schemas, name) unless block_given?
+
+      register(:schemas, name, options, &block)
+    end
+
+    def endpoint(path, options = {}, &block)
+      return resolve(:endpoints, Endpoint.normalize_name(path)) unless block_given?
+
+      register(:endpoints, path, options, &block)
+    end
+
+    private
+
+    def create_schema_registry(schemas, registry = nil)
+      return registry.(schemas) if registry
+
+      Registry.new(schemas, error: SchemaNotFound) do |name, options = {}, block|
+        @objects[name] = Attributes.create(:object, name, options, &block)
+      end
+    end
+
+    def create_endpoint_registry(endpoints, registry = nil)
+      return registry.(endpoints) if registry
+
+      Registry.new(endpoints, error: EndpointNotFound) do |path, options = {}, block|
+        endpoint = Endpoint.new(path, options, &block)
+        @objects[endpoint.name] = endpoint
+      end
+    end
+  end
+end

data/lib/tomyum/serializer.rb

@@ -0,0 +1,125 @@
+module Tomyum
+  # user_schema = Attributes.create(:object) do
+  #   string :username
+  #   string :email
+  # end
+  #
+  # user = <any object>
+  #
+  # resolver   = Resolver.new(schemas: [user_schema, ...])
+  # serializer.serialize(user_schema, user)
+  class Serializer < Tomyum::Attributes::Visitor
+    include Tomyum::Resolvable
+
+    InvalidPredicate = Tomyum::Error.create("Invalid predicate value (must be either Symbol or Proc)")
+
+    def initialize(resolver = nil)
+      @resolver = resolver
+    end
+
+    # Override to make it accepts 3 arguments
+    def normalize_attribute(attribute, object, options = {})
+      super(attribute, options)
+    end
+
+    # catch all
+    def visit_attribute(attribute, object, options = {})
+      attribute.serialize(attribute.value(object))
+    end
+
+    # Primitive attribute
+    # -------------------
+    # serialize(string, "user")
+    # serialize(object, { name: "john" })
+    #
+    # Schema Attribute
+    # ----------------
+    # schema = Attributes.create(:object, :user) do
+    #   string :username
+    # end
+    #
+    # class User
+    #   def initialize(data)
+    #     @data = data
+    #   end
+    #
+    #   def username
+    #     @data[:name]
+    #   end
+    # end
+    # user = User.new(name: "john")
+    #
+    # serialize(schema, user)
+    alias :serialize :visit
+
+    # Defines visitors for primitive types e.g. `visit_string` etc
+    Tomyum::Attributes::SCALAR_TYPES.each do |type|
+      alias_method "visit_#{type}", :visit_attribute
+    end
+
+    def visit_object(attribute, object, options = {})
+      visit_object_handler(attribute, object) do |attr, value, attrs|
+        attrs[attr.name] = visit(attr, value, options)
+      end
+    end
+
+    def visit_array(attribute, object, options = {})
+      as = attribute.of
+
+      Array(object).map do |item|
+        # item#serialize_as will be used when of: option is not specified.
+        # e.g. ListSerializer.schema has `array :data`
+        # as = attribute.of || (item.serialize_as if item.respond_to?(:serialize_as))
+        unless as.kind_of?(Symbol)
+          item
+        else
+          visit(as, item, options)
+        end
+      end
+    end
+
+    def visit_schema(attribute, object, options = {})
+      attribute = resolver.schema(attribute.of)
+
+      visit_object(attribute, object, options)
+    end
+
+    private
+
+    def get(object, name)
+      object.respond_to?(name) ? object.send(name) : object&.fetch(name, nil)
+    end
+
+    def visit_object_handler(attribute, object)
+      attribute.attributes.values.each_with_object({}) do |attr, attrs|
+        next unless serializable?(attr, object)
+
+        # get value for each field
+        value = get(object, attr.method)
+
+        yield(attr, value, attrs)
+      end
+    end
+
+    def serializable?(attr, object)
+      return unless attr.serializable?
+
+      # check predicate :if and :unless
+      return execute_predicate(attr.if, object)      if attr.if
+      return !execute_predicate(attr.unless, object) if attr.unless
+
+      true
+    end
+
+    def execute_predicate(predicate, object)
+      case predicate
+      when Symbol
+        get(object, predicate)
+      when Proc
+        predicate.call(object)
+      else
+        raise InvalidPredicate
+      end
+    end
+  end
+end

data/lib/tomyum/serializers/serializable.rb

@@ -0,0 +1,23 @@
+module Tomyum
+  module Serializers
+    module Serializable
+      extend Tomyum::Support
+
+      included do
+        class << self
+          attr_accessor :serializer
+
+          def serializer
+            @serializer || superclass.serializer
+          end
+        end
+
+        self.serializer = ->(v) { v }
+      end
+
+      def serialize(value)
+        self.class.serializer.(value)
+      end
+    end
+  end
+end

data/lib/tomyum/server/app.rb

@@ -0,0 +1,33 @@
+module Tomyum
+  module Server
+    class App
+      def initialize(resolver = nil)
+        @resolver = resolver
+      end
+
+      def call(env)
+        resolver = Tomyum::Resolver.new do
+          endpoint "/users" do
+            get :create, path: "/"
+          end
+        end
+
+        body = ['<h1>Hello</h1>']
+        resolver.endpoints.keys.each do |key|
+          endpoint = resolver.endpoints.get(key)
+          methods  = endpoint.methods
+          methods.map do |name, method|
+            path = [endpoint.path, method.path].map { |r| r.chomp '/' }.reject(&:empty?).join("/")
+            if env["REQUEST_PATH"] == path && env["REQUEST_METHOD"].downcase == method.verb.to_s
+              body = ["Path #{path}"]
+            end
+          end
+        end
+
+        status  = 200
+        headers = { "Content-Type" => "text/html" }
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/tomyum/server/document.rb

@@ -0,0 +1,20 @@
+require_relative "documents/swagger"
+require_relative "documents/redoc"
+
+module Tomyum
+  module Server
+    class Document
+      def initialize(app, path: "/doc")
+        @app = app
+        @path = path
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        return @app.call(env) if request.path != @path
+
+        [200, {}, [Documents::Redoc.new.call]]
+      end
+    end
+  end
+end

data/lib/tomyum/server/documents/redoc.rb

@@ -0,0 +1,36 @@
+module Tomyum
+  module Server
+    module Documents
+      class Redoc
+        def call
+<<~HTML
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Redoc</title>
+    <!-- needed for adaptive design -->
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+
+    <!--
+    Redoc doesn't change outer page styles
+    -->
+    <style>
+      body {
+        margin: 0;
+        padding: 0;
+      }
+    </style>
+  </head>
+  <body>
+    <redoc spec-url='http://petstore.swagger.io/v2/swagger.json'></redoc>
+    <script src="https://cdn.jsdelivr.net/npm/redoc@latest/bundles/redoc.standalone.js"> </script>
+  </body>
+</html>
+HTML
+        end
+      end
+    end
+  end
+end

data/lib/tomyum/server/documents/swagger.rb

@@ -0,0 +1,47 @@
+module Tomyum
+  module Server
+    module Documents
+      class Swagger
+        def call
+ <<~HTML
+  <!DOCTYPE html>
+  <html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+      <meta charset="UTF-8">
+      <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@3.12.1/swagger-ui.css">
+  </head>
+  <body>
+
+  <div id="swagger-ui"></div>
+
+  <script src="https://unpkg.com/swagger-ui-dist@3.12.1/swagger-ui-standalone-preset.js"></script>
+  <script src="https://unpkg.com/swagger-ui-dist@3.12.1/swagger-ui-bundle.js"></script>
+
+  <script>
+
+      window.onload = function() {
+          // Build a system
+          const ui = SwaggerUIBundle({
+              url: "https://petstore.swagger.io/v2/swagger.json",
+              dom_id: '#swagger-ui',
+              deepLinking: true,
+              presets: [
+                  SwaggerUIBundle.presets.apis,
+                  SwaggerUIStandalonePreset
+              ],
+              // plugins: [
+              //    SwaggerUIBundle.plugins.DownloadUrl
+              // ],
+              layout: "StandaloneLayout",
+          })
+          // window.ui = ui
+      }
+  </script>
+  </body>
+  </html>
+HTML
+        end
+      end
+    end
+  end
+end

data/lib/tomyum/support.rb

@@ -0,0 +1,13 @@
+module Tomyum
+  module Support
+    # Mimic Active Support's .included behaviours
+    def included(base = nil, &block)
+      if base.nil?
+        @_included_block = block
+      else
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+      end
+    end
+  end
+end