easy-jsonapi 1.0.0

data/lib/easy/jsonapi/parser.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/parser/rack_req_params_parser'
+require 'easy/jsonapi/parser/headers_parser'
+require 'easy/jsonapi/parser/document_parser'
+require 'easy/jsonapi/request'
+
+require 'rack'
+
+module JSONAPI
+  # Parsing logic in rack middleware
+  module Parser
+    # @param env [Hash] The rack envirornment hash
+    # @return [JSONAPI::Request] the instantiated jsonapi request object
+    def self.parse_request(env)
+      req = Rack::Request.new(env)
+
+      query_param_collection = RackReqParamsParser.parse(req.GET)
+      header_collection = HeadersParser.parse(env)
+
+      req_body = req.body.read # stored separately because can only read 1x
+      req.body.rewind # rewind incase something else needs to read the body of the request
+      document = includes_jsonapi_document?(env) ? DocumentParser.parse(req_body) : nil
+
+      JSONAPI::Request.new(env, query_param_collection, header_collection, document)
+    end
+
+    # Is the content type jsonapi?
+    # @param (see #parse_request)
+    # @return [TrueClass | FalseClass]
+    def self.includes_jsonapi_document?(env)
+      env['CONTENT_TYPE'] == 'application/vnd.api+json' &&
+        env['REQUEST_METHOD'] != 'GET'
+    end
+
+    private_class_method :includes_jsonapi_document?
+  end
+end

data/lib/easy/jsonapi/parser/document_parser.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/document'
+require 'oj'
+
+module JSONAPI
+  module Parser
+
+    # TODO: Only parse valid object members, currenlty parses any included members.
+    # Document Parsing Logic
+    module DocumentParser
+
+      # Parse the JSONAPI Request into objects.
+      # @param req_body [String]  The supplied JSONAPI document with POST, PATCH, PUT, or DELETE.
+      # @return [JSONAPI::Document] The parsed JSONAPI document.
+      # @raise [JSONAPI::Parser::InvalidDocument] if document is invalid.
+      def self.parse(req_body)
+        return if req_body.nil?
+        document_hash = Oj.load(req_body, symbol_keys: true) # parse json string into hash
+        parse_hash(document_hash)
+      end
+
+      # Parse the JSONAPI Request into objects.
+      # @param document_hash [Hash] The jsonapi-like ruby hash to parse into objects
+      # @return (see #parse)
+      # @raise (see #parse)
+      def self.parse_hash(document_hash)
+        return if document_hash.nil?
+        doc_members_hash = parse_top_level_members(document_hash)
+        JSONAPI::Document.new(doc_members_hash)
+      end
+
+      # @param document (see #parse!)
+      # @return [Hash] A hash containing the objects needed to initialize a 
+      #   JSONAPI::Document
+      def self.parse_top_level_members(document)
+        doc_members_hash = {}
+        doc_members_hash[:data] = parse_resources(document[:data]) if document.key?(:data)
+        doc_members_hash[:meta] = parse_meta(document[:meta]) if document.key?(:meta)
+        doc_members_hash[:links] = parse_links(document[:links]) if document.key?(:links)
+        doc_members_hash[:included] = parse_included(document[:included]) if document.key?(:included)
+        doc_members_hash[:errors] = parse_errors(document[:errors]) if document.key?(:errors)
+        doc_members_hash[:jsonapi] = parse_jsonapi(document[:jsonapi]) if document.key?(:jsonapi)
+        doc_members_hash
+      end
+
+      # @param res_arr [Array<Hash> | Hash] A collection of resources or a resource.
+      # @return [JSONAPI::Document::Resource | Array<JSONAPI::Document::Resource>]
+      #   A resource or collection of resources
+      def self.parse_resources(res_arr)
+        case res_arr
+        when Array
+          res_arr.map { |res| parse_resource(res) }
+        when Hash
+          parse_resource(res_arr)
+        else
+          raise 'The top level data member must be an array of resources or a resource'
+        end
+      end
+
+      # @param res [Hash] The resource hash to parse
+      # @return [JSONAPI::Document::Resource] The parsed resource
+      def self.parse_resource(res)
+        attributes = parse_attributes(res[:attributes]) if res[:attributes]
+        relationships = parse_relationships(res[:relationships]) if res[:relationships]
+        links = parse_links(res[:links]) if res[:links]
+        meta = parse_meta(res[:meta]) if res[:meta]
+
+        res_members_hash = {
+          type: res[:type],
+          id: res[:id],
+          attributes: attributes,
+          relationships: relationships,
+          links: links,
+          meta: meta
+        }
+
+        JSONAPI::Document::Resource.new(res_members_hash)
+      end
+
+      # @param attrs_hash [Hash] The attributes hash to parse
+      # @return [JSONAPI::Document::Resource::Attributes] The parsed attributes
+      def self.parse_attributes(attrs_hash)
+        attributes = JSONAPI::Document::Resource::Attributes.new
+        attrs_hash.each do |name, value|
+          cur_attr = JSONAPI::Document::Resource::Attributes::Attribute.new(name, value)
+          attributes.add(cur_attr)
+        end
+        attributes
+      end
+
+      # @param rels_hash [Hash] The relationships hash to parse
+      # @return [JSONAPI::Document::Resource::Relationships] The parsed
+      #   relationships
+      def self.parse_relationships(rels_hash)
+        relationships = JSONAPI::Document::Resource::Relationships.new
+        rels_hash.each do |name, value|
+          rel = parse_relationship(name, value)
+          relationships.add(rel)
+        end
+        relationships
+      end
+
+      # @param name [String | Symbol] The name of the relationship being parsed
+      # @param rel_hash [Hash] The relationship to parse
+      # @return [JSONAPI::Document::Resource::Relationships::Relationship]
+      #   The parsed relationship
+      def self.parse_relationship(name, rel_hash)
+        links = parse_links(rel_hash[:links]) if rel_hash[:links]
+        data = parse_resource_identifiers(rel_hash[:data]) if rel_hash[:data]
+        meta = parse_meta(rel_hash[:meta]) if rel_hash[:meta]
+        
+        rel_members_hash = { name: name, links: links, data: data, meta: meta }
+        JSONAPI::Document::Resource::Relationships::Relationship.new(rel_members_hash)
+      end
+
+      # @param links_hash [Hash] The links hash to parse
+      # @return [JSONAPI::Document::Links] The parsed links object
+      def self.parse_links(links_hash)
+        links = JSONAPI::Document::Links.new
+        links_hash.each do |name, value|
+          cur_link = JSONAPI::Document::Links::Link.new(name, value)
+          links.add(cur_link)
+        end
+        links
+      end
+
+      # @param meta_hash [Hash] The meta hash to parse
+      # @return [JSONAPI::Document::Meta] The parsed meta object
+      def self.parse_meta(meta_hash)
+        meta = JSONAPI::Document::Meta.new
+        meta_hash.each do |name, value|
+          cur_meta_member = JSONAPI::Document::Meta::MetaMember.new(name, value)
+          meta.add(cur_meta_member)
+        end
+        meta
+      end
+
+      # @param res_id_arr [Hash | Array<Hash>] The resource identifier or
+      #   array of resource identifiers to parse
+      # @return [JSONAPI::Document::ResourceId | Array<JSONAPI::Document::ResourceId]
+      #   The parsed resource identifier or array or resource identifiers
+      def self.parse_resource_identifiers(res_id_arr)
+        res_id_hashs = []
+        case res_id_arr
+        when Array
+          res_id_arr.each do |res_id|
+            res_id_hashs << parse_resource_identifier(res_id)
+          end
+          res_id_hashs
+        when Hash
+          parse_resource_identifier(res_id_arr)
+        else
+          raise 'Data member of resource relationship was not an array or hash'
+        end
+      end
+
+      # @param res_id [Hash] The resource identifier to parse
+      # @return [JSONAPI::Document::ResourceId] The parsed resource identifier
+      def self.parse_resource_identifier(res_id)
+        JSONAPI::Document::ResourceId.new(type: res_id[:type], id: res_id[:id])
+      end
+
+      # @param included_arr [Array<Hash>] The array of included resoures to parse
+      # @return [Array<JSONAPI::Document::Resource] The array of parsed included resources
+      def self.parse_included(included_arr)
+        res_arr = []
+        included_arr.each do |res|
+          res_arr << parse_resource(res)
+        end
+        res_arr
+      end
+
+      # @param errs_arr [Array<Hash>] The array of errors to parse
+      # @return [Array<JSONAPI::Document::Error>] The parsed error objects
+      def self.parse_errors(errs_arr)
+        errs_hash_arr = []
+        errs_arr.each do |err_hash|
+          errs_hash_arr << parse_error(err_hash)
+        end
+        errs_hash_arr
+      end
+
+      # @param err_hash [Hash] The error hash to parse
+      # @return [JSONAPI::Document::Error] The parsed error object
+      def self.parse_error(err_hash)
+        error = JSONAPI::Document::Error.new
+        err_hash.each do |name, value|
+          error.add(JSONAPI::Document::Error::ErrorMember.new(name, value))
+        end
+        error
+      end
+
+    end
+  end
+end

data/lib/easy/jsonapi/parser/headers_parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/collection'
+require 'easy/jsonapi/header_collection'
+
+require 'easy/jsonapi/item'
+require 'easy/jsonapi/header_collection/header'
+
+require 'easy/jsonapi/exceptions/headers_exceptions'
+
+module JSONAPI
+  module Parser
+
+    # Header parsing logic
+    module HeadersParser
+      
+      # @param env [Hash] The rack envirornment hash
+      # @return [JSONAPI::HeaderCollection] The collection of parsed header objects
+      def self.parse(env)
+        h_collection = JSONAPI::HeaderCollection.new
+        env.each_key do |k|
+          if k.start_with?('HTTP_') && (k != 'HTTP_VERSION')
+            h_collection << JSONAPI::HeaderCollection::Header.new(k[5..], env[k])
+          elsif k == 'CONTENT_TYPE'
+            h_collection << JSONAPI::HeaderCollection::Header.new(k, env[k])
+          end
+        end
+        h_collection
+      end
+    end
+
+  end
+end

data/lib/easy/jsonapi/parser/rack_req_params_parser.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/exceptions/query_params_exceptions'
+
+require 'easy/jsonapi/request/query_param_collection'
+
+require 'easy/jsonapi/request/query_param_collection/query_param'
+
+require 'easy/jsonapi/request/query_param_collection/filter_param'
+require 'easy/jsonapi/request/query_param_collection/filter_param/filter'
+
+require 'easy/jsonapi/request/query_param_collection/include_param'
+require 'easy/jsonapi/request/query_param_collection/page_param'
+require 'easy/jsonapi/request/query_param_collection/sort_param'
+
+require 'easy/jsonapi/request/query_param_collection/fields_param'
+require 'easy/jsonapi/request/query_param_collection/fields_param/fieldset'
+
+require 'easy/jsonapi/field'
+
+module JSONAPI
+  module Parser
+    
+    # Used to parse the request params given from the Rack::Request object
+    module RackReqParamsParser
+      
+      # @param rack_req_params [Hash<String>]  The parameter hash returned from Rack::Request.params
+      # @return [JSONAPI::Request::QueryParamCollection]
+      def self.parse(rack_req_params)
+        
+        # rack::request.params: (string keys)
+        # {
+        #   'fields' => { 'articles' => 'title,body,author', 'people' => 'name' },
+        #   'include' => 'author,comments-likers,comments.users',
+        #   'josh_ua' => 'demoss,simpson',
+        #   'page' => { 'offset' => '5', 'limit' => '20' },
+        #   'filter' => { 'comments' => '(author/age > 21)', 'users' => '(age < 15)' },
+        #   'sort' => 'age,title'
+        # }
+
+        query_param_collection = JSONAPI::Request::QueryParamCollection.new
+        rack_req_params.each do |name, value|
+          add_the_param(name, value, query_param_collection)
+        end
+        query_param_collection
+      end
+
+      class << self
+        private
+
+        # @param name [String] The name of the query param to add
+        # @param value [String | Hash] The value of the query param to add
+        # @param query_param_collection [JSONAPI::Request::QueryParamCollection]
+        #   The collection to add all the params to
+        def add_the_param(name, value, query_param_collection)
+          case name
+          when 'include'
+            query_param_collection.add(parse_include_param(value))
+          when 'fields'
+            query_param_collection.add(parse_fields_param(value))
+          when 'sort'
+            query_param_collection.add(parse_sort_param(value))
+          when 'page'
+            query_param_collection.add(parse_page_param(value))
+          when 'filter'
+            query_param_collection.add(parse_filter_param(value))
+          else
+            query_param_collection.add(parse_query_param(name, value))
+          end
+        end
+
+        # @param value [String] The value to initialize with
+        def parse_include_param(value)
+          includes_arr = value.split(',')
+          JSONAPI::Request::QueryParamCollection::IncludeParam.new(includes_arr)
+        end
+
+        # @param (see #parse_include_param)
+        def parse_fields_param(value)
+          fieldsets = []
+          value.each do |res_type, res_field_str|
+            res_field_str_arr = res_field_str.split(',')
+            res_field_arr = res_field_str_arr.map { |res_field| JSONAPI::Field.new(res_field) }
+            fieldsets << JSONAPI::Request::QueryParamCollection::FieldsParam::Fieldset.new(res_type, res_field_arr)
+          end
+          JSONAPI::Request::QueryParamCollection::FieldsParam.new(fieldsets)
+        end
+
+        # @param (see #parse_include_param)
+        def parse_sort_param(value)
+          res_field_arr = value.split(',').map { |res_field| JSONAPI::Field.new(res_field) }
+          JSONAPI::Request::QueryParamCollection::SortParam.new(res_field_arr)
+        end
+
+        # @param (see #parse_include_param)
+        def parse_page_param(value)
+          JSONAPI::Request::QueryParamCollection::PageParam.new(offset: value[:offset], limit: value[:limit])
+        end
+
+        # @param (see #parse_include_param)
+        def parse_filter_param(value)
+          
+          filter_arr = value.map do |res_name, filter|
+            JSONAPI::Request::QueryParamCollection::FilterParam::Filter.new(res_name, filter)
+          end
+          JSONAPI::Request::QueryParamCollection::FilterParam.new(filter_arr)
+        end
+
+        # @param (see #parse_include_param)
+        def parse_query_param(name, value)
+          JSONAPI::Request::QueryParamCollection::QueryParam.new(name, value)
+        end
+        
+      end
+    end
+  end
+end

data/lib/easy/jsonapi/request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  # Contains all objects relating to a HTTP request
+  class Request
+    attr_reader :path, :http_method, :host, :port, :query_string, :params, :headers, :body
+
+    # @param env The rack envirornment hash
+    # @param query_param_collection [QueryParamCollection]  The already initialized QueryParamCollection class
+    # @param header_collection [HeaderCollection]  The already initialized HeaderCollection class
+    # @param document [Document]  The already initialized Document class
+    def initialize(env, query_param_collection, header_collection, document)
+      # from env hash
+      @path = env['REQUEST_PATH']
+      @http_method = env['REQUEST_METHOD']
+      @host = env['SERVER_NAME']
+      @port = env['SERVER_PORT'].to_i
+      @query_string = env['QUERY_STRING']
+
+      # parsed objects
+      @params = query_param_collection
+      @headers = header_collection
+      @body = document
+    end
+
+    # Simple representation of a request object.
+    def to_s
+      "Quick Access Methods:\n\n" \
+        "\tpath: #{@path}\n" \
+        "\thttp: #{@http}\n" \
+        "\thost: #{@host}\n" \
+        "\tport: #{@port}\n" \
+        "\tquery_string: #{@query_string}\n\n" \
+      "Accessing main sections of request:\n\n" \
+        "\tparams: #{@params}\n" \
+        "\theaders: #{@headers}\n" \
+        "\tbody: #{@body}" \
+    end
+  end
+end

data/lib/easy/jsonapi/request/query_param_collection.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/name_value_pair_collection'
+require 'easy/jsonapi/utility'
+
+module JSONAPI
+  class Request
+    # A collection of QueryParam objects 
+    class QueryParamCollection < JSONAPI::NameValuePairCollection
+
+      # @param param_arr [Array<JSONAPI::Request::QueryParamCollection::QueryParam] The
+      #   query params to initialize the collection with
+      def initialize(param_arr = [])
+        @param_names = []
+        super(param_arr, item_type: JSONAPI::Request::QueryParamCollection::QueryParam)
+      end
+  
+      # #empyt? provided by super class
+      # #include provided by super class
+      
+      # Add a QueryParameter to the collection. (CASE-SENSITIVE)
+      # @param param [JSONAPI::Request::QueryParamCollection::QueryParam] The param to add
+      def add(param)
+        super(param, &:name)
+      end
+
+      # #<< provided by super, but calls overriden #add
+      # #each provided from super
+      # #remove provided from super
+      # #get provided by super
+      # #keys provided by super
+      # #size provided by super
+
+      # Represent query param collection like the query_param string
+      def to_s
+        JSONAPI::Utility.to_string_collection(self, delimiter: '&')
+      end
+
+      private
+
+      # Gets the QueryParam object whose name matches the method_name called
+      # @param method_name [Symbol] The name of the method called
+      # @param args If any arguments were passed to the method called
+      # @param block If a block was passed to the method called
+      def method_missing(method_name, *args, &block)
+        super unless include?(method_name)
+        get(method_name)
+      end
+
+      # Whether or not method missing should be called.
+      def respond_to_missing?(method_name, *)
+        include?(method_name) || super
+      end
+    end
+  end
+end