apia 3.0.0

data/lib/apia/request_headers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Apia
+  class RequestHeaders
+
+    def initialize(headers)
+      @headers = headers
+    end
+
+    def fetch(key, default = nil)
+      @headers[self.class.make_key(key)] || default
+    end
+
+    def [](key)
+      fetch(key)
+    end
+
+    def []=(key, value)
+      @headers[self.class.make_key(key)] = value
+    end
+
+    class << self
+
+      def make_key(key)
+        key.gsub('-', '_').upcase
+      end
+
+      def create_from_request(request)
+        hash = request.each_header.each_with_object({}) do |(key, value), inner_hash|
+          next unless key =~ /\AHTTP_(\w+)\z/
+
+          name = Regexp.last_match[1]
+
+          inner_hash[name] = value
+        end
+        new(hash)
+      end
+
+    end
+
+  end
+end

data/lib/apia/response.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'apia/rack'
+
+module Apia
+  class Response
+
+    attr_accessor :status
+    attr_reader :fields
+    attr_reader :headers
+    attr_writer :body
+
+    def initialize(request, endpoint)
+      @request = request
+      @endpoint = endpoint
+
+      @status = @endpoint.definition.http_status_code
+      @fields = {}
+      @headers = {}
+    end
+
+    # Add a field value for this endpoint
+    #
+    # @param name [Symbol]
+    # @param value [Hash, Object, nil]
+    # @return [void]
+    def add_field(name, value)
+      @fields[name.to_sym] = value
+    end
+
+    # Add a header to the response
+    #
+    # @param name [String]
+    # @param value [String]
+    # @return [void]
+    def add_header(name, value)
+      @headers[name.to_s] = value&.to_s
+    end
+
+    # Return the full hash of data that should be returned for this
+    # request.
+    #
+    # @return [Hash]
+    def hash
+      @hash ||= @endpoint.definition.fields.generate_hash(@fields, request: @request)
+    end
+
+    # Return the body that should be returned for this response
+    #
+    # @return [Hash]
+    def body
+      @body || hash
+    end
+
+    # Return the rack triplet for this response
+    #
+    # @return [Array]
+    def rack_triplet
+      Rack.json_triplet(body, headers: @headers, status: @status)
+    end
+
+  end
+end

data/lib/apia/route.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'apia/route_set'
+
+module Apia
+  class Route
+
+    REQUEST_METHODS = [:get, :post, :patch, :put, :delete].freeze
+
+    attr_reader :path
+    attr_reader :controller
+    attr_reader :request_method
+    attr_reader :group
+    attr_writer :endpoint
+
+    def initialize(path, **options)
+      @path = path
+
+      @group = options[:group]
+
+      @controller = options[:controller]
+      @endpoint = options[:endpoint]
+
+      @request_method = options[:request_method] || :get
+    end
+
+    # Return the endpoint object for this route
+    #
+    # @return [Apia::Endpoint]
+    def endpoint
+      if @endpoint.is_a?(Symbol) && controller
+        return controller.definition.endpoints[@endpoint]
+      end
+
+      @endpoint
+    end
+
+    # Return the parts for this route
+    #
+    # @return [Array<String>]
+    def path_parts
+      @path_parts ||= RouteSet.split_path(@path)
+    end
+
+    # Extract arguments from the given path and return a hash of the arguments
+    # based on their naming from the route
+    #
+    # @param given_path [String]
+    # @return [Hash]
+    def extract_arguments(given_path)
+      given_path_parts = RouteSet.split_path(given_path)
+      path_parts.each_with_index.each_with_object({}) do |(part, index), hash|
+        next unless part =~ /\A:(\w+)/
+
+        value = given_path_parts[index]
+        hash[Regexp.last_match[1]] = value
+      end
+    end
+
+  end
+end

data/lib/apia/route_group.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Apia
+  class RouteGroup
+
+    attr_reader :id
+    attr_reader :parent
+    attr_accessor :name
+    attr_accessor :description
+    attr_accessor :default_controller
+    attr_reader :groups
+
+    def initialize(id, parent)
+      @id = id
+      @parent = parent
+      @groups = []
+    end
+
+  end
+end

data/lib/apia/route_set.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'apia/dsls/route_set'
+
+module Apia
+  class RouteSet
+
+    attr_reader :map
+    attr_reader :routes
+    attr_reader :controllers
+    attr_reader :endpoints
+    attr_reader :groups
+
+    def initialize
+      @map = {}
+      @routes = []
+      @controllers = []
+      @endpoints = []
+      @groups = []
+    end
+
+    def dsl
+      @dsl ||= DSLs::RouteSet.new(self)
+    end
+
+    # Add a new route to the set
+    #
+    # @param route [Moonstone::Route]
+    # @return [Moonstone::Route]
+    def add(route)
+      @routes << route
+      if route.controller && !@controllers.include?(route.controller)
+        @controllers << route.controller
+      end
+
+      if route.endpoint && !@controllers.include?(route.endpoint)
+        @endpoints << route.endpoint
+      end
+
+      parts = self.class.split_path(route.path).map { |p| p =~ /\A:/ ? '?' : p }
+      parts.size.times do |i|
+        if i.zero?
+          source = @map
+        else
+          source = @map.dig(*parts[0, i])
+        end
+        source[parts[i]] ||= { _routes: [] }
+        source[parts[i]][:_routes] << route if i == parts.size - 1
+      end
+      route
+    end
+
+    # Find routes that exactly match a given path
+    #
+    # @param request_method [Symbol]
+    # @param path [String]
+    # @return [Array<Moonstone::Route>]
+    def find(request_method, path)
+      parts = self.class.split_path(path)
+      last = @map
+      parts.size.times do |i|
+        last = last[parts[i]] || last['?']
+        return [] if last.nil?
+      end
+      last[:_routes].select { |r| r.request_method == request_method }
+    end
+
+    class << self
+
+      # Remove slashes from the start and end of a given string
+      #
+      # @param string [String]
+      # @return [String]
+      def strip_slashes(string)
+        string.sub(/\A\/+/, '').sub(/\/\z/, '')
+      end
+
+      # Split a URL part into its appropriate parts
+      #
+      # @param path [String]
+      # @return [Array<String>]
+      def split_path(path)
+        strip_slashes(path).split('/')
+      end
+
+    end
+
+  end
+end

data/lib/apia/scalar.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'apia/helpers'
+require 'apia/definitions/scalar'
+require 'apia/defineable'
+
+module Apia
+  class Scalar
+
+    extend Defineable
+
+    # Return the definition for this type
+    #
+    # @return [Apia::Definitions::Object]
+    def self.definition
+      @definition ||= Definitions::Scalar.new(Helpers.class_name_to_id(name))
+    end
+
+    def self.cast(value = nil, &block)
+      if block_given? && value.nil?
+        return definition.dsl.cast(&block)
+      end
+
+      unless valid?(value)
+        # Before casting, we'll also validate...
+        raise InvalidScalarValueError.new(self, value)
+      end
+
+      value = definition.cast.call(value) if definition.cast
+
+      value
+    end
+
+    def self.valid?(value)
+      return true if definition.validator.nil?
+
+      definition.validator.call(value)
+    end
+
+    def self.parse(value = nil, &block)
+      if block_given? && value.nil?
+        return definition.dsl.parse(&block)
+      end
+
+      return value if definition.parse.nil?
+      return nil if value.nil?
+
+      definition.parse.call(value)
+    end
+
+  end
+end

data/lib/apia/scalars.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Apia
+  module Scalars
+
+    class << self
+
+      def fetch(item, default = nil)
+        all[item.to_sym] || default
+      end
+
+      def register(name, klass)
+        all[name.to_sym] = klass
+      end
+
+      private
+
+      def all
+        @all ||= {}
+      end
+
+    end
+
+  end
+end

data/lib/apia/scalars/base64.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'apia/scalars'
+require 'apia/scalar'
+require 'base64'
+
+module Apia
+  module Scalars
+    class Base64 < Apia::Scalar
+
+      Scalars.register :base64, self
+
+      name 'Base64-encoded string'
+
+      cast do |value|
+        ::Base64.encode64(value).sub(/\n\z/, '')
+      end
+
+      validator { true }
+
+      parse do |value|
+        unless value.is_a?(::String)
+          raise Apia::ParseError, 'Base64 value must be provided as a string'
+        end
+
+        ::Base64.decode64(value)
+      end
+
+    end
+  end
+end

data/lib/apia/scalars/boolean.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'apia/scalars'
+require 'apia/scalar'
+
+module Apia
+  module Scalars
+    class Boolean < Apia::Scalar
+
+      Scalars.register :boolean, self
+
+      name 'Boolean'
+
+      TRUE_VALUES = [true, 'true', 'yes', 1, '1'].freeze
+      FALSE_VALUES = [false, 'false', 'no', 0, '0'].freeze
+
+      cast do |value|
+        value ? true : false
+      end
+
+      validator do |value|
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+
+      parse do |value|
+        if TRUE_VALUES.include?(value)
+          true
+        elsif FALSE_VALUES.include?(value)
+          false
+        else
+          raise Apia::ParseError, 'Boolean must be provided as a boolean, as a string containing true or false or as 0 or 1 as an integer.'
+        end
+      end
+
+    end
+  end
+end

data/lib/apia/scalars/date.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'apia/scalars'
+require 'apia/scalar'
+require 'apia/errors/parse_error'
+
+module Apia
+  module Scalars
+    class Date < Apia::Scalar
+
+      Scalars.register :date, self
+
+      name 'Date'
+
+      cast do |value|
+        value.strftime('%Y-%m-%d')
+      end
+
+      validator do |value|
+        value.is_a?(::Date)
+      end
+
+      parse do |string|
+        next string if string.is_a?(::Date)
+
+        begin
+          string = string.to_s
+          unless string =~ /\A\d{4}-\d{2}-\d{2}\z/
+            raise Apia::ParseError, 'Date must be in the format of yyyy-mm-dd'
+          end
+
+          ::Date.parse(string)
+        rescue ::ArgumentError => e
+          if e.message =~ /invalid date/
+            raise Apia::ParseError, 'Invalid date was entered (make sure the day exists)'
+          end
+
+          raise
+        end
+      end
+
+    end
+  end
+end