bluepine 0.1.1

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

@@ -0,0 +1,111 @@
+module Bluepine
+  module Generators
+    module OpenAPI
+      # Generate property based on Open API Spec (shared for both Omise/Open API specs)
+      class PropertyGenerator < Bluepine::Attributes::Visitor
+        include Bluepine::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 SchemaAttribute
+        def visit_schema(attr, options)
+          return build_ref(attr.of) unless attr.expandable
+
+          # SchemaAttribute#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)
+          Bluepine::Attributes.create(object.to_sym, object)
+        end
+
+        private
+
+        def build(attr, options = {})
+          assert_kind_of Bluepine::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-omise-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/bluepine/registry.rb

@@ -0,0 +1,75 @@
+module Bluepine
+  # 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 Bluepine::Assertions
+
+    KeyError = Bluepine::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/bluepine/resolvable.rb

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

data/lib/bluepine/resolver.rb

@@ -0,0 +1,99 @@
+module Bluepine
+  # 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   = Bluepine::Endpoint
+    Attributes = Bluepine::Attributes
+
+    SchemaNotFound   = Bluepine::Error.create("Endpoint %s cannot be found")
+    EndpointNotFound = Bluepine::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/bluepine/serializer.rb

@@ -0,0 +1,125 @@
+module Bluepine
+  # 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 < Bluepine::Attributes::Visitor
+    include Bluepine::Resolvable
+
+    InvalidPredicate = Bluepine::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
+    Bluepine::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/bluepine/serializers/serializable.rb

@@ -0,0 +1,25 @@
+module Bluepine
+  module Serializers
+    module Serializable
+      extend ActiveSupport::Concern
+
+      included do
+        # Serializer
+        class_attribute :serializer
+
+        # Default serializer
+        self.serializer = ->(v) { v }
+      end
+
+      def serialize(value)
+        self.class.serialize(value)
+      end
+
+      module ClassMethods
+        def serialize(value)
+          serializer.(value)
+        end
+      end
+    end
+  end
+end