lurch 0.1.0

data/lib/lurch/errors/not_loaded.rb

@@ -0,0 +1,13 @@
+module Lurch
+  module Errors
+    class NotLoaded < StandardError
+      def initialize(type)
+        @type = type
+      end
+
+    private
+
+      attr_reader :type
+    end
+  end
+end

data/lib/lurch/errors/relationship_not_loaded.rb

@@ -0,0 +1,9 @@
+module Lurch
+  module Errors
+    class RelationshipNotLoaded < NotLoaded
+      def message
+        "Relationship (#{type}) not loaded, try calling #fetch first."
+      end
+    end
+  end
+end

data/lib/lurch/errors/resource_not_loaded.rb

@@ -0,0 +1,9 @@
+module Lurch
+  module Errors
+    class ResourceNotLoaded < NotLoaded
+      def message
+        "Resource (#{type}) not loaded, try calling #fetch first."
+      end
+    end
+  end
+end

data/lib/lurch/errors/server_error.rb

@@ -0,0 +1,6 @@
+module Lurch
+  module Errors
+    class ServerError < JSONApiError
+    end
+  end
+end

data/lib/lurch/errors/unauthorized.rb

@@ -0,0 +1,6 @@
+module Lurch
+  module Errors
+    class Unauthorized < JSONApiError
+    end
+  end
+end

data/lib/lurch/errors/unprocessable_entity.rb

@@ -0,0 +1,6 @@
+module Lurch
+  module Errors
+    class UnprocessableEntity < JSONApiError
+    end
+  end
+end

data/lib/lurch/inflector.rb

@@ -0,0 +1,60 @@
+module Lurch
+  class Inflector
+    def initialize(inflection_mode, types_mode)
+      define_encode_key(inflection_mode)
+      define_encode_type(types_mode)
+    end
+
+    def self.classify(s)
+      Inflecto.classify(s)
+    end
+
+    def self.decode_key(key)
+      Inflecto.underscore(key.to_s).to_sym
+    end
+
+    def self.decode_type(type)
+      Inflecto.pluralize(decode_key(type)).to_sym
+    end
+
+    def define_encode_key(inflection_mode)
+      case inflection_mode
+      when :dasherize
+        define_singleton_method(:encode_key) { |key| Inflecto.dasherize(key.to_s) }
+      when :underscore
+        define_singleton_method(:encode_key) { |key| Inflecto.underscore(key.to_s) }
+      else
+        raise ArgumentError, "Invalid inflection mode: #{inflection_mode}"
+      end
+    end
+
+    def define_encode_type(types_mode)
+      case types_mode
+      when :pluralize
+        define_singleton_method(:encode_type) do |type|
+          key = encode_key(type)
+          Inflecto.pluralize(key)
+        end
+      when :singularize
+        define_singleton_method(:encode_type) do |type|
+          key = encode_key(type)
+          Inflecto.singularize(key)
+        end
+      else
+        raise ArgumentError, "Invalid types mode: #{types_mode}"
+      end
+    end
+
+    def encode_keys(hash)
+      hash.each_with_object({}) do |(key, value), acc|
+        acc[encode_key(key)] = block_given? ? yield(value) : value
+      end
+    end
+
+    def encode_types(hash)
+      hash.each_with_object({}) do |(key, value), acc|
+        acc[encode_type(key)] = block_given? ? yield(value) : value
+      end
+    end
+  end
+end

data/lib/lurch/logger.rb

@@ -0,0 +1,7 @@
+module Lurch
+  class Logger
+    def self.debug(&block)
+      Lurch.configuration.logger.debug("Lurch", &block)
+    end
+  end
+end

data/lib/lurch/middleware/json_api_request.rb

@@ -0,0 +1,22 @@
+module Lurch
+  module Middleware
+    class JSONApiRequest < Faraday::Middleware
+      CONTENT_TYPE = "Content-Type".freeze
+      ACCEPT = "Accept".freeze
+      MIME_TYPE = "application/vnd.api+json".freeze
+
+      dependency do
+        require "json" unless defined?(::JSON)
+      end
+
+      def call(env)
+        env[:request_headers][CONTENT_TYPE] = MIME_TYPE
+        env[:request_headers][ACCEPT] = MIME_TYPE
+        env[:body] = JSON.generate(env[:body]) if env[:body].is_a?(Hash)
+        @app.call(env)
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware jsonapi: -> { Lurch::Middleware::JSONApiRequest }

data/lib/lurch/middleware/json_api_response.rb

@@ -0,0 +1,24 @@
+module Lurch
+  module Middleware
+    class JSONApiResponse < Faraday::Middleware
+      MIME_TYPE = "application/vnd.api+json".freeze
+
+      dependency do
+        require "json" unless defined?(::JSON)
+      end
+
+      def call(conn)
+        @app.call(conn).on_complete do |env|
+          env[:body_raw] = env[:body]
+          begin
+            env[:body] = JSON.parse(env[:body])
+          rescue StandardError => err
+            env[:parse_error] = err
+          end
+        end
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware jsonapi: -> { Lurch::Middleware::JSONApiResponse }

data/lib/lurch/paginator.rb

@@ -0,0 +1,71 @@
+module Lurch
+  class Paginator
+    def initialize(store, document, inflector, config)
+      @store = store
+      @links = document["links"]
+      @meta = document["meta"]
+      @config = config
+      @inflector = inflector
+    end
+
+    def record_count
+      key = @inflector.encode_key(@config.pagination_record_count_key)
+      @meta[key]
+    end
+
+    def page_count
+      key = @inflector.encode_key(@config.pagination_page_count_key)
+      @meta[key]
+    end
+
+    def next_collection
+      next_link && @store.load_from_url(next_link)
+    end
+
+    def prev_collection
+      prev_link && @store.load_from_url(prev_link)
+    end
+
+    def first_collection
+      first_link && @store.load_from_url(first_link)
+    end
+
+    def last_collection
+      last_link && @store.load_from_url(last_link)
+    end
+
+    def next?
+      !!next_link
+    end
+
+    def prev?
+      !!prev_link
+    end
+
+    def first?
+      !!first_link
+    end
+
+    def last?
+      !!last_link
+    end
+
+  private
+
+    def next_link
+      @links["next"]
+    end
+
+    def prev_link
+      @links["prev"]
+    end
+
+    def first_link
+      @links["first"]
+    end
+
+    def last_link
+      @links["last"]
+    end
+  end
+end

data/lib/lurch/payload_builder.rb

@@ -0,0 +1,43 @@
+module Lurch
+  class PayloadBuilder
+    def initialize(inflector)
+      @inflector = inflector
+    end
+
+    def build(input, identifier_only = false)
+      { "data" => data(input, identifier_only) }
+    end
+
+  private
+
+    def data(input, identifier_only)
+      if input.is_a?(Enumerable)
+        input.map { |resource| resource_object_for(resource, identifier_only) }
+      else
+        resource_object_for(input, identifier_only)
+      end
+    end
+
+    def resource_object_for(resource, identifier_only)
+      return nil if resource.nil?
+      {
+        "id" => resource.id,
+        "type" => @inflector.encode_type(resource.type),
+        "attributes" => attributes_for(resource, identifier_only),
+        "relationships" => relationships_for(resource, identifier_only)
+      }.reject { |_, v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }
+    end
+
+    def attributes_for(resource, identifier_only)
+      return {} if identifier_only
+      @inflector.encode_keys(resource.attributes)
+    end
+
+    def relationships_for(resource, identifier_only)
+      return {} if identifier_only
+      @inflector.encode_keys(resource.relationships) do |value|
+        PayloadBuilder.new(@inflector).build(value, true)
+      end
+    end
+  end
+end

data/lib/lurch/query.rb

@@ -0,0 +1,143 @@
+module Lurch
+  class Query
+    def initialize(store, inflector)
+      @store = store
+      @inflector = inflector
+      @filter = {}
+      @include = []
+      @fields = Hash.new { [] }
+      @sort = []
+      @page = {}
+    end
+
+    def filter(params)
+      @filter.merge!(params)
+      self
+    end
+
+    def include(*relationship_paths)
+      @include += relationship_paths
+      self
+    end
+
+    def fields(type, fields = nil)
+      type, fields = [@type, type] if type.is_a?(Array) && fields.nil?
+      @fields[type] += fields
+      self
+    end
+
+    def sort(*sort_keys)
+      @sort += sort_keys.map { |sort_key| sort_key.is_a?(Hash) ? sort_key : { sort_key => :asc } }
+      self
+    end
+
+    def page(params)
+      @page.merge!(params)
+      self
+    end
+
+    def type(type)
+      @type = Inflector.decode_type(type)
+      self
+    end
+
+    # def link(uri)
+    #   # TODO: fail if type already set
+    #   # TODO: set uri and merge in query params from provided uri if any
+    #   self
+    # end
+
+    def all
+      raise ArgumentError, "No type specified for query" if @type.nil?
+      @store.load_from_url(uri_builder.resources_uri(@type, to_query))
+    end
+
+    def find(id)
+      raise ArgumentError, "No type specified for query" if @type.nil?
+      raise ArgumentError, "Can't perform find for `nil`" if id.nil?
+      @store.peek(@type, id) || @store.load_from_url(uri_builder.resource_uri(@type, id, to_query))
+    end
+
+    def save(changeset)
+      raise ArgumentError, "No type specified for query" if @type.nil?
+      raise ArgumentError, "Type mismatch" if @type != changeset.type
+      @store.save(changeset, to_query)
+    end
+
+    def insert(changeset)
+      raise ArgumentError, "No type specified for query" if @type.nil?
+      raise ArgumentError, "Type mismatch" if @type != changeset.type
+      @store.insert(changeset, to_query)
+    end
+
+    def delete(resource)
+      raise ArgumentError, "No type specified for query" if @type.nil?
+      raise ArgumentError, "Type mismatch" if @type != resource.type
+      @store.delete(resource, to_query)
+    end
+
+    def inspect
+      type = @type.nil? ? "" : "[#{Inflector.classify(@type)}]"
+      query = to_query
+      query = query.empty? ? "" : " #{query.inspect}"
+      "#<#{self.class}#{type}#{query}>"
+    end
+
+  private
+
+    def uri_builder
+      @uri_builder ||= URIBuilder.new(@inflector)
+    end
+
+    def to_query
+      QueryBuilder.new(
+        {
+          filter: filter_query,
+          include: include_query,
+          fields: fields_query,
+          sort: sort_query,
+          page: page_query
+        }.merge(other_uri_params)
+      ).encode
+    end
+
+    def other_uri_params
+      # TODO: existing non-standard uri query params from the provided uri (if any)
+      {}
+    end
+
+    def filter_query
+      @inflector.encode_keys(@filter)
+    end
+
+    def include_query
+      @include.map { |path| @inflector.encode_key(path) }.compact.uniq.join(",")
+    end
+
+    def fields_query
+      @inflector.encode_types(@fields) do |fields|
+        fields.map { |field| @inflector.encode_key(field) }.compact.uniq.join(",")
+      end
+    end
+
+    def sort_query
+      @sort.flat_map(&:to_a).map { |(key, direction)| sort_key(key, direction) }.join(",")
+    end
+
+    def sort_key(key, direction)
+      encoded_key = @inflector.encode_key(key)
+      case direction
+      when :asc
+        encoded_key
+      when :desc
+        "-#{encoded_key}"
+      else
+        raise ArgumentError, "Invalid sort direction #{direction}"
+      end
+    end
+
+    def page_query
+      @page
+    end
+  end
+end

data/lib/lurch/query_builder.rb

@@ -0,0 +1,26 @@
+module Lurch
+  class QueryBuilder
+    def initialize(params)
+      @params = Hash(params)
+    end
+
+    def encode
+      encode_value(@params)
+    end
+
+  private
+
+    def encode_value(value, key = nil)
+      case value
+      when Hash  then value.map { |k, v| encode_value(v, append_key(key, k)) }.reject(&:empty?).join("&")
+      when Array then value.map { |v| encode_value(v, "#{key}[]") }.reject(&:empty?).join("&")
+      else
+        value.to_s.empty? ? "" : "#{key}=#{CGI.escape(value.to_s)}"
+      end
+    end
+
+    def append_key(root_key, key)
+      root_key.nil? ? key : "#{root_key}[#{key}]"
+    end
+  end
+end

data/lib/lurch/railtie.rb

@@ -0,0 +1,9 @@
+module Lurch
+  class Railtie < ::Rails::Railtie
+    initializer "lurch.initialization" do
+      Lurch.configure do |config|
+        config.logger = Rails.logger
+      end
+    end
+  end
+end

data/lib/lurch/relationship/has_many.rb

@@ -0,0 +1,17 @@
+module Lurch
+  class Relationship
+    class HasMany < Relationship
+      def initialize(store, relationship_key, document)
+        @store = store
+        @relationship_key = relationship_key
+        @document = document
+        @data = @document["data"].map { |resource_identifier| Resource.new(@store, resource_identifier["type"], resource_identifier["id"]) }
+      end
+
+      def inspect
+        suffix = @data.first ? "[#{Inflector.classify(@data.first.type)}]" : ""
+        "#<#{self.class}#{suffix} size: #{@data.size}>"
+      end
+    end
+  end
+end

data/lib/lurch/relationship/has_one.rb

@@ -0,0 +1,21 @@
+module Lurch
+  class Relationship
+    class HasOne < Relationship
+      def initialize(store, relationship_key, document)
+        @store = store
+        @relationship_key = relationship_key
+        if document["data"].nil?
+          @data = nil
+        else
+          @type = Inflector.decode_type(document["data"]["type"])
+          @id = document["data"]["id"]
+          @data = Resource.new(@store, @type, @id)
+        end
+      end
+
+      def inspect
+        @data.nil? ? "#<#{self.class} nil>" : "#<#{self.class}[#{Inflector.classify(@type)}] id: #{@id.inspect}>"
+      end
+    end
+  end
+end

data/lib/lurch/relationship/linked.rb

@@ -0,0 +1,40 @@
+module Lurch
+  class Relationship
+    class Linked < Relationship
+      def initialize(store, relationship_key, document)
+        @store = store
+        @relationship_key = relationship_key
+        @href = document["links"]["related"]
+      end
+
+      def fetch
+        @data = @store.load_from_url(@href)
+      end
+
+      # def filter(*args)
+      #   @store.query.link(@href).filter(*args)
+      # end
+      #
+      # def include(*args)
+      #   @store.query.link(@href).include(*args)
+      # end
+      #
+      # def fields(*args)
+      #   @store.query.link(@href).fields(*args)
+      # end
+      #
+      # def sort(*args)
+      #   @store.query.link(@href).sort(*args)
+      # end
+      #
+      # def page(*args)
+      #   @store.query.link(@href).page(*args)
+      # end
+
+      def inspect
+        suffix = loaded? ? " \"loaded\"" : ""
+        "#<#{self.class} href: #{@href.inspect}#{suffix}>"
+      end
+    end
+  end
+end

data/lib/lurch/relationship.rb

@@ -0,0 +1,26 @@
+module Lurch
+  class Relationship
+    attr_reader :data
+
+    def self.from_document(store, relationship_key, document)
+      return Relationship::HasMany.new(store, relationship_key, document) if document.key?("data") && document["data"].is_a?(Array)
+      return Relationship::HasOne.new(store, relationship_key, document) if document.key?("data")
+      return Relationship::Linked.new(store, relationship_key, document) if document.key?("links") && document["links"].key?("related")
+      raise ArgumentError, "Invalid relationship document"
+    end
+
+    def loaded?
+      !!defined?(@data)
+    end
+
+    def respond_to_missing?(method, all)
+      raise Errors::RelationshipNotLoaded, @relationship_key unless loaded?
+      super
+    end
+
+    def method_missing(method, *arguments, &block)
+      raise Errors::RelationshipNotLoaded, @relationship_key unless loaded?
+      super
+    end
+  end
+end

data/lib/lurch/resource.rb

@@ -0,0 +1,82 @@
+module Lurch
+  class Resource
+    attr_reader :id, :type
+
+    def initialize(store, type, id)
+      @store = store
+      @type = Inflector.decode_type(type)
+      @id = id
+    end
+
+    def loaded?
+      !!resource_from_store
+    end
+
+    def fetch
+      @store.from(type).find(id)
+      self
+    end
+
+    def attributes
+      raise Errors::ResourceNotLoaded, resource_class_name unless loaded?
+
+      resource_from_store.attributes
+    end
+
+    def relationships
+      raise Errors::ResourceNotLoaded, resource_class_name unless loaded?
+
+      resource_from_store.relationships
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+
+    def eql?(other)
+      id == other.id && type == other.type
+    end
+
+    def [](attribute)
+      raise Errors::ResourceNotLoaded, resource_class_name unless loaded?
+
+      resource_from_store.attribute(attribute)
+    end
+
+    def resource_class_name
+      Inflector.classify(type)
+    end
+
+    def inspect
+      inspection = if loaded?
+                     attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(", ")
+                   else
+                     "not loaded"
+                   end
+      "#<#{self.class}[#{resource_class_name}] id: #{id.inspect}, #{inspection}>"
+    end
+
+  private
+
+    def resource_from_store
+      @store.resource_from_store(type, id)
+    end
+
+    def respond_to_missing?(method, all)
+      return super unless loaded?
+      resource_from_store.attribute?(method) || resource_from_store.relationship?(method) || super
+    end
+
+    def method_missing(method, *arguments, &block)
+      raise Errors::ResourceNotLoaded, resource_class_name unless loaded?
+
+      return resource_from_store.attribute(method) if resource_from_store.attribute?(method)
+      if resource_from_store.relationship?(method)
+        rel = resource_from_store.relationship(method)
+        return rel.loaded? ? rel.data : rel
+      end
+
+      super
+    end
+  end
+end