shaf 1.5.1 → 2.1.0

data/lib/shaf/parser.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Shaf
+  module Parser
+    class Error < StandardError; end
+
+    INPUT_BODY = 'shaf.input_body'
+
+    class << self
+      def register(parser)
+        parsers << parser
+      end
+
+      def unregister(parser)
+        parsers.delete(parser)
+      end
+
+      def input?(request)
+        !!input(request)
+      end
+
+      def for(request)
+        clazz = parser_for(request)
+        return unless clazz
+
+        body = input(request)
+        clazz.new(request: request, body: body)
+      end
+
+      private
+
+      def parser_for(request)
+        parsers.find do |parser|
+          parser.can_handle? request
+        end
+      end
+
+      def parsers
+        @parsers ||= Set.new
+      end
+
+      def input(request)
+        body = request.get_header(INPUT_BODY)
+        body ||= read_input(request).tap do |b|
+          request.set_header(INPUT_BODY, b)
+        end
+
+        body unless String(body).strip.empty?
+      end
+
+      def read_input(request)
+        request.body.rewind
+        request.body.read
+      ensure
+        request.body.rewind
+      end
+    end
+  end
+end
+
+require 'shaf/parser/base'
+require 'shaf/parser/json'
+require 'shaf/parser/form_data'

data/lib/shaf/parser/base.rb

@@ -0,0 +1,44 @@
+module Shaf
+  module Parser
+    class Base
+      class << self
+        def inherited(child)
+          Parser.register(child)
+          super
+        end
+
+        def mime_type(type = nil, value = nil)
+          if type
+            @mime_type = type
+            @mime_type = Sinatra::Base.mime_type(type, value) if type.is_a? Symbol
+          end
+
+          @mime_type if defined? @mime_type
+        end
+
+        def can_handle?(request)
+          mime_type == request.content_type
+        end
+
+      end
+
+      attr_reader :request, :body
+
+      def initialize(request:, body:)
+        @request = request
+        @body = body
+      end
+
+      def call
+        raise NotImplementedError, "#{self.class} must implement #call"
+      end
+
+      private
+
+      def mime_type
+        self.class.mime_type
+      end
+    end
+  end
+end
+

data/lib/shaf/parser/form_data.rb

@@ -0,0 +1,15 @@
+module Shaf
+  module Parser
+    class FormData < Base
+      def self.can_handle?(request)
+        request.form_data? || request.parseable_data?
+      end
+
+      def call
+        request.POST.tap do |data| # Returns form params from Rack::Request
+          data.delete '_method' # If the method override hack is used remove the _method key
+        end
+      end
+    end
+  end
+end

data/lib/shaf/parser/json.rb

@@ -0,0 +1,26 @@
+module Shaf
+  module Parser
+    class Json < Base
+
+      mime_type :json, 'application/json'
+
+      def self.can_handle?(request)
+        request.content_type&.match? %r{application/(.*\+)?json}
+      end
+
+      def call
+        @payload ||= parse_json
+      end
+
+      private
+
+      def parse_json
+        return {} if body.empty?
+
+        JSON.parse(body, symbolize_names: true)
+      rescue JSON::ParserError => e
+        raise Error, e.message
+      end
+    end
+  end
+end

data/lib/shaf/profile.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'shaf/profile/evaluator'
+require 'shaf/extensions/resource_uris'
+
+module Shaf
+  class Profile
+    include Shaf::UriHelper
+
+    class << self
+      def inherited(child)
+        Profiles.register child
+      end
+
+      def name(str = nil)
+        @name = str if str
+        @name if defined? @name
+      end
+
+      def doc(str = nil)
+        @doc = str if str
+        @doc if defined? @doc
+      end
+
+      def urn(value = nil)
+        @urn = value if value
+        @urn if defined? @urn
+      end
+
+      def example(str)
+        examples << str
+      end
+
+      def match?(str)
+        normalize(name) == normalize(str)
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+
+      def relations
+        @relations ||= []
+      end
+
+      def examples
+        @examples ||= []
+      end
+
+      def attribute(*args, **kwargs, &block)
+        evaluator.attribute(*args, **kwargs, &block)
+      end
+
+      def relation(*args, **kwargs, &block)
+        evaluator.rel(*args, **kwargs, &block)
+      end
+      alias rel relation
+
+      def descriptor(id)
+        find_attribute(id) || find_relation(id)
+      end
+
+      def find_attribute(id)
+        attributes.find { |attr| attr.id.to_sym == id.to_sym }
+      end
+
+      def find_relation(id)
+        relations.find { |rel| rel.id.to_sym == id.to_sym }
+      end
+
+      def use(*descriptors, from:, doc: nil)
+        descriptors.each do |id|
+          desc = from.descriptor(id)
+          href = profile_path(from.name, fragment_id: id)
+
+          case desc
+          when Relation
+            kwargs = {
+              doc: doc || desc&.doc,
+              href: href,
+              http_methods: desc.http_methods,
+              payload_type: desc.payload_type,
+              content_type: desc.content_type,
+            }
+            relation(id, **kwargs)
+          when Attribute
+            attribute(id, href: href, doc: doc)
+          when NilClass
+            raise "#{from.name} does not have a descriptor with id #{id}"
+          else
+            raise Errors::ServerError, "Unsupported descriptor: #{desc}"
+          end
+        end
+      end
+
+      private
+
+      def evaluator
+        Evaluator.new(parent: self)
+      end
+
+      def normalize(name)
+        name.to_s.downcase.tr('-', '_')
+      end
+    end
+
+    def name
+      normalize(self.class.name)
+    end
+
+    def normalize(str)
+      self.class.normalize(str)
+    end
+  end
+end

data/lib/shaf/profile/attribute.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'shaf/profile/unique_id'
+
+module Shaf
+  class Profile
+    class Attribute
+      include UniqueId
+
+      attr_reader :name, :doc, :href, :type, :parent
+
+      def initialize(name, **opts)
+        @name = name.to_sym
+        @doc = opts[:doc].freeze
+        @href = opts[:href].freeze
+        @type = opts[:type]&.to_s
+        @parent = opts[:parent]
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+
+      def relations
+        @relations ||= []
+      end
+    end
+  end
+end

data/lib/shaf/profile/evaluator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'shaf/profile/attribute'
+require 'shaf/profile/relation'
+
+module Shaf
+  class Profile
+    class Evaluator
+      attr_reader :parent, :allowed
+
+      def initialize(parent:, allowed: nil)
+        @parent = parent
+        @allowed = allowed && Array(allowed).map(&:to_sym)
+      end
+
+      def attribute(name, doc:, type: :string, &block)
+        return unless allow? :attribute
+
+        attr = Attribute.new(name, doc: doc, type: type, parent: parent)
+        self.class.new(parent: attr, allowed: allowed).instance_exec(&block) if block
+        parent.attributes << attr
+      end
+
+      def relation(name, **kwargs, &block)
+        return unless allow? :rel
+
+        rel = Relation.new(name, parent: parent, **kwargs)
+        self.class.new(parent: rel, allowed: [:attribute]).instance_exec(&block) if block
+        parent.relations << rel
+      end
+      alias rel relation
+
+      private
+
+      def allow?(name)
+        return true unless allowed
+        return true if allowed.include? name
+
+        Shaf.log.warn "#{name} is not allowed to be nested inside #{parent.class} " \
+          "(or parent object containing #{parent.class})"
+
+        false
+      end
+    end
+  end
+end

data/lib/shaf/profile/relation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'shaf/profile/unique_id'
+
+module Shaf
+  class Profile
+    class Relation
+      include UniqueId
+
+      attr_reader :name, :doc, :href, :http_methods, :payload_type, :content_type, :parent
+
+      def initialize(name, **opts)
+        @name = name.to_sym
+        @doc = opts[:doc].freeze
+        @href = opts[:href].freeze
+        http_methods = Array(opts[:http_method]) + Array(opts[:http_methods])
+        http_methods  << 'GET' if http_methods.empty?
+        @http_methods = http_methods.map { |m| m.to_s.upcase }.uniq.freeze
+        @payload_type = opts[:payload_type].freeze
+        @content_type = opts[:content_type].freeze
+        @parent = opts[:parent]
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+    end
+  end
+end

data/lib/shaf/profile/unique_id.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Shaf
+  class Profile
+    module UniqueId
+      def id
+        return @id if defined? @id
+        @id = __find_unique_id
+      end
+
+      def __pending_id?
+        @__pending_id ||= false
+      end
+
+      private
+
+      def __find_unique_id
+        @__pending_id = true
+
+        return name.to_s unless __id_collision? name.to_s
+
+        id = [parent.name, name].join('_')
+        return id unless __id_collision? id
+
+        id = "#{id}0"
+
+        loop do
+          id = id.next
+          break id unless __id_collision? id
+        end
+      ensure
+        @__pending_id = false
+      end
+
+      def __id_collision? id
+        descriptor = self
+
+        loop do
+          break false unless descriptor.respond_to?(:parent) && descriptor.parent
+          descriptor = descriptor.parent
+
+          __parent_descriptors(descriptor).each do |desc|
+            next if desc == self
+            next if desc.__pending_id?
+            return true if desc.id == id
+          end
+        end
+      end
+
+      def __parent_descriptors(parent)
+        descriptors = []
+        descriptors += parent.attributes if parent.respond_to? :attributes
+        descriptors += parent.relations if parent.respond_to? :relations
+        descriptors
+      end
+    end
+  end
+end

data/lib/shaf/profiles.rb

@@ -0,0 +1,46 @@
+require 'shaf/errors'
+
+module Shaf
+  module Profiles
+    class ProfileNotFoundError < Errors::NotFoundError
+      def initialize(name)
+        msg = %Q(Profile with name "#{name}" does not exist)
+        super(msg, id: name)
+      end
+    end
+
+    class << self
+      def register(clazz)
+        profiles << clazz
+      end
+
+      def unregister(clazz)
+        profiles.delete(clazz)
+      end
+
+      def find(name)
+        name = String(name)
+        return if name.empty?
+
+        profiles.find { |profile| profile.match? name }
+      end
+
+      def find!(name)
+        find(name) or raise ProfileNotFoundError, name
+      end
+
+      def profiles
+        @profiles ||= []
+      end
+
+      def clear
+        @profiles.clear
+      end
+    end
+  end
+end
+
+require 'shaf/profile'
+require 'shaf/profiles/shaf_form'
+require 'shaf/profiles/shaf_error'
+require 'shaf/profiles/shaf_basic'