bluepine 0.1.1

data/lib/bluepine/attributes/ip_address_attribute.rb

@@ -0,0 +1,15 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class IPAddressAttribute < StringAttribute
+      def spec
+        "RFC 2673 § 3.2"
+      end
+
+      def spec_uri
+        "https://tools.ietf.org/html/rfc2673#section-3.2"
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/number_attribute.rb

@@ -0,0 +1,24 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class NumberAttribute < Attribute
+      self.serializer = ->(v) { v.to_s.include?(".") ? v.to_f : v.to_i }
+
+      RULES = {
+        max: {
+          group: :numericality,
+          name:  :less_than_or_equal,
+        },
+        min: {
+          group: :numericality,
+          name:  :greater_than_or_equal,
+        },
+      }.freeze
+
+      def native_type
+        "number"
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/object_attribute.rb

@@ -0,0 +1,71 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class ObjectAttribute < Attribute
+      class_attribute :stacks
+      attr_reader     :attributes
+
+      self.stacks = []
+
+      def initialize(name, options = {}, &block)
+        @name       = name
+        @options    = options
+        @attributes = {}
+        instance_exec(&block) if block_given?
+      end
+
+      def native_type
+        "object"
+      end
+
+      # Apply default options to all attributes
+      #
+      # group if: :deleted? { ... }
+      # group unless: :deleted? { ... }
+      # group if: ->{ @user.deleted? } { ... }
+      def group(options, &block)
+        return unless block_given?
+
+        # Use stacks to allow nested conditions
+        self.class.stacks << Attribute.options
+        Attribute.options = options
+
+        instance_exec(&block)
+
+        # restore options
+        Attribute.options = self.class.stacks.pop
+      end
+
+      # Shortcut for creating attribute (delegate call to Registry.create)
+      # This allows us to access newly registered attributes
+      #
+      #   string :username (or array, number etc)
+      def method_missing(type, name = nil, options = {}, &block)
+        if Attributes.registry.key?(type)
+          @attributes[name] = Attributes.create(type, name, options, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, *)
+        super
+      end
+
+      def [](name)
+        @attributes[name.to_sym]
+      end
+
+      def []=(name, attribute)
+        assert_kind_of Attribute, attribute
+
+        @attributes[name.to_sym] = attribute
+      end
+
+      def keys
+        @attributes.keys
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/schema_attribute.rb

@@ -0,0 +1,23 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    # Reference to other schema and doesn't accept &block.
+    #
+    # SchemaAttribute supports extra option named `expandable`
+    # which will either return `id` or `serialized object`
+    # as the result.
+    class SchemaAttribute < ObjectAttribute
+      DEFAULT_EXPANDABLE = false
+      def initialize(name, options = {})
+        # automatically add name to :of if it's not given
+        options[:of] = name unless options.key?(:of)
+        @expandable  = options.fetch(:expandable, DEFAULT_EXPANDABLE)
+
+        super
+      end
+
+      attr_reader :expandable
+    end
+  end
+end

data/lib/bluepine/attributes/string_attribute.rb

@@ -0,0 +1,36 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class StringAttribute < Attribute
+      self.serializer = ->(v) { v.to_s }
+
+      RULES = {
+        match: {
+          group: :format,
+          name:  :with,
+        },
+        min: {
+          group: :length,
+          name:  :minimum,
+        },
+        max: {
+          group: :length,
+          name:  :maximum,
+        },
+        range: {
+          group: :length,
+          name:  :in,
+        },
+      }.freeze
+
+      def native_type
+        "string"
+      end
+
+      def in
+        super&.map(&:to_s)
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/time_attribute.rb

@@ -0,0 +1,19 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class TimeAttribute < StringAttribute
+      def format
+        super || "date-time"
+      end
+
+      def spec
+        "ISO 8601"
+      end
+
+      def spec_uri
+        "https://en.wikipedia.org/wiki/ISO_8601"
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/uri_attribute.rb

@@ -0,0 +1,19 @@
+require "bluepine/attributes/attribute"
+
+module Bluepine
+  module Attributes
+    class URIAttribute < StringAttribute
+      def format
+        super || type
+      end
+
+      def spec
+        "RFC 3986"
+      end
+
+      def spec_uri
+        "https://tools.ietf.org/html/rfc3986"
+      end
+    end
+  end
+end

data/lib/bluepine/attributes/visitor.rb

@@ -0,0 +1,136 @@
+module Bluepine
+  module Attributes
+    # An abstract Visitor for traversing {Attribute}.
+    #
+    # Sub-classes must implement the methods correspond to {Attribute} classes.
+    #
+    # @example Implements +string+ visitor for {StringAttribute}
+    #   class SimpleVisitor < Bluepine::Attributes::Visitor
+    #     def visit_string(attribute, *args)
+    #       "Hello #{attribute.name}"
+    #     end
+    #   end
+    #
+    #   # Usage
+    #   username = Attributes.create(:string, :username)
+    #   visitor  = StringVisitor.new
+    #   visitor.visit(username) # => "Hello username"
+    #
+    # @abstract
+    class Visitor
+      include Functions
+
+      MethodNotFound = Bluepine::Error.create("Cannot find method Visitor#%s")
+
+      # Traveres a visitable object and calls corresponding method based-on
+      # sub-classes' impementations.
+      #
+      # @example When +attribute+ is an instance of {Attribute}.
+      #   object = Attributes.create(:object, :user) { }
+      #   visit(object) # => visit_object
+      #
+      # @example When +attribute+ is a {Symbol}.
+      #   visit(:user) # => visit_user or visit_schema(attr, of: :user)
+      #
+      # @param [Attribute|Symbol] The +Attribute+ object or +Symbol+
+      def visit(attribute, *args)
+        method, attribute = find_method!(attribute, *args)
+
+        send(method, attribute, *args)
+      end
+
+      # Performs visitor logic when no corresponding method can be found (Catch-all).
+      def visit_attribute(attribute, options = {})
+        raise NotImplementedError
+      end
+
+      def visit_schema(attribute, options = {})
+        raise NotImplementedError
+      end
+
+      private
+
+      # Finds a vistor method.
+      #
+      # @return Array<String, Attribute> Pair of method name and +Attribute+ object
+      #
+      # It'll return a first callable method in the chains or return +nil+ when no methods can be found.
+      # If +attribute+ is a Symbol. It'll stop looking any further.
+      #
+      #   find_method(:integer) # => `visit_integer`
+      #
+      # If it's an instance of <tt>Attribute</tt>. It'll look up in ancestors
+      # chain and return the first callable method.
+      #
+      #   object = Attributes.create(:object, :name) { ... }
+      #   find_method(object) => `visit_object`
+      def find_method(attribute, *args)
+        compose(
+          curry(:resolve_methods),
+          curry(:respond_to_visitor?),
+          curry(:normalize_symbol, attribute, args)
+        ).(attribute)
+      end
+
+      def find_method!(attribute, *args)
+        method, attribute = find_method(attribute, *args)
+
+        raise MethodNotFound, normalize_method(attribute) unless method
+
+        [method, attribute]
+      end
+
+      # Returns list of method Symbols from given +Attribute+
+      #
+      # @return [Symbol] Method symbols e.g. [:string, StringAttribute, Attribute]
+      def resolve_methods(attribute)
+        return [attribute] if attribute.kind_of?(Symbol)
+
+        # Finds all ancestors in hierarchy up to `Attribute`
+        parents = attribute.class.ancestors.map(&:to_s)
+        parents.slice(0, parents.index(Attribute.name).to_i + 1)
+      end
+
+      def normalize_method(method)
+        return unless method
+
+        # Cannot use `chomp("Attribute")` here, because the top most class is `Attribute`
+        "visit_" + method.to_s.demodulize.gsub(/(\w+)Attribute/, "\\1").underscore
+      end
+
+      # Creates Attribute from symbol
+      # e.g. :integer to IntegerAttribute
+      def normalize_attribute(attribute, options = {})
+        return attribute unless Attributes.key?(attribute)
+
+        Attributes.create(attribute, attribute.to_s, options)
+      end
+
+      # Finds method from method list that respond_to `visit_{attribute}` call
+      def respond_to_visitor?(methods)
+        methods.find { |m| respond_to?(normalize_method(m)) }
+      end
+
+      def normalize_symbol(attribute, args, method)
+        # When we can't find method e.g. `visit_{method}`
+        # and `attribute` is a symbol (e.g. :user),
+        # we'll enforce the same logic for all visitor sub-classes
+        # by calling `visit_schema` with of: attribute
+        if !method && attribute.kind_of?(Symbol)
+          method, attribute = normalize_schema_symbol(attribute, *args)
+        end
+
+        [
+          normalize_method(method),
+          normalize_attribute(attribute, *args),
+        ]
+      end
+
+      def normalize_schema_symbol(schema, *args)
+        args.last[:of] = schema if args.last.is_a?(Hash)
+
+        [:schema, :schema]
+      end
+    end
+  end
+end

data/lib/bluepine/endpoint.rb

@@ -0,0 +1,102 @@
+require "bluepine/endpoints/params"
+require "bluepine/endpoints/method"
+
+module Bluepine
+  class Endpoint
+    include Bluepine::Assertions
+
+    # See `docs/api/endpoint-validations.md`.
+    HTTP_METHODS_WITHOUT_BODY = %i[get head trace]
+    HTTP_METHODS_WITH_BODY    = %i[post put patch delete]
+    HTTP_METHODS = HTTP_METHODS_WITHOUT_BODY + HTTP_METHODS_WITH_BODY
+
+    class << self
+      # Converts `/users/:id/friends` to `users_id_friends`
+      def normalize_name(name)
+        name.to_s.delete(":").gsub(/(\A\/+|\/+\z)/, '').tr('/', '_').to_sym
+      end
+    end
+
+    DEFAULT_OPTIONS = {
+      schema:      nil,
+      title:       nil,
+      description: nil,
+    }.freeze
+
+    attr_reader   :path, :name, :schema
+    attr_accessor :title, :description
+
+    def initialize(path, options = {}, &block)
+      options  = DEFAULT_OPTIONS.merge(options)
+      @schema  = options[:schema]
+      @path    = path
+      @name    = normalize_name(options[:name])
+      @methods = {}
+      @params  = nil
+      @block   = block
+      @loaded  = false
+      @title   = options[:title]
+      @description = options[:description]
+    end
+
+    # Defines http methods dynamically e.g. :get, :post ...
+    #   endpoint.define do
+    #     get :index, path: "/"
+    #     post :create
+    #   end
+    HTTP_METHODS.each do |method|
+      define_method method do |action, path: "/", **options|
+        create_method(method, action, path: path, **options)
+      end
+    end
+
+    # Lazily builds all params and return methods hash
+    def methods(resolver = nil)
+      ensure_loaded
+
+      @methods.each { |name, _| method(name, resolver: resolver) }
+    end
+
+    # Lazily builds params for speicified method
+    def method(name, resolver: nil)
+      ensure_loaded
+      assert_in @methods, name.to_sym
+
+      @methods[name.to_sym].tap { |method| method.build_params(params, resolver) }
+    end
+
+    # Returns default params
+    def params(&block)
+      ensure_loaded
+
+      @params ||= Bluepine::Endpoints::Params.new(:default, schema: schema, built: true, &block || -> {})
+    end
+
+    # Registers http verb method
+    #
+    #   create_method(:post, :create, path: "/")
+    def create_method(verb, action, path: "/", **options)
+      # Automatically adds it self as schema value
+      options[:schema] = options.fetch(:schema, schema)
+
+      @methods[action.to_sym] = Bluepine::Endpoints::Method.new(verb, action: action, path: path, **options)
+    end
+
+    private
+
+    def normalize_name(name)
+      (name || @schema || self.class.normalize_name(@path)).to_sym
+    end
+
+    # Lazily executes &block
+    def ensure_loaded
+      return if @loaded
+
+      # We need to set status here; otherwise, we'll have
+      # error when there's nested block.
+      @loaded = true
+
+      instance_exec(&@block) if @block
+    end
+  end
+end