hal_presenter 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9322632b515fd679f3bde7bcd8f0c3725330a66f3e4d8439f3223c3bc70f2e4e
+  data.tar.gz: 56e87ad4268c7bf247d9bf593fb0c6c91358a2d0d61a39824085075c4cbd9944
+SHA512:
+  metadata.gz: 7c1663fc6ba1427c4a30162892dd3ccc4ae551b299990657d3cbac06566d32483112a77527baab2c05316c57bc2ac65e3b5cc4ee91ddfb8317fd8b0afaf4da51
+  data.tar.gz: f99e735e37406ec5c7e370e9cc08fa74babbd135c6ceb60160c980e5a132c8c70d1412c7e0b585c868f6eece599bd2e88220ef2be26e8671e08b5236472c3200

checksums.yaml.gz.sig

@@ -0,0 +1 @@
+
��?t�=����rF5���=�<��cя�H�s1U��ϯ�
��Kcb��qy����ⵃ�Y����п��Me�G'U��;W�I������yBi�:&��y��ݠc�v� p��5�Ɗ���'scL��/ś��]���Y�ᓵ/ҭ��S�Z�L�����&�)����1��d	�2N��`y{�<)u��n�E*��n�C��lP�!��`��n�EԲ�;��8=����qΡ$�OB�fW��e	�x�

data/lib/hal_presenter.rb

@@ -0,0 +1,33 @@
+require 'hal_presenter/model'
+require 'hal_presenter/policy'
+require 'hal_presenter/policy/dsl'
+require 'hal_presenter/attributes'
+require 'hal_presenter/links'
+require 'hal_presenter/embedded'
+require 'hal_presenter/curies'
+require 'hal_presenter/serializer'
+require 'hal_presenter/deserializer'
+require 'hal_presenter/collection'
+require 'hal_presenter/serialize_hooks'
+
+module HALPresenter
+  include HALPresenter::Attributes
+  include HALPresenter::Links
+  include HALPresenter::Curies
+  include HALPresenter::Embedded
+  include HALPresenter::Collection
+  include HALPresenter::SerializeHooks
+  include HALPresenter::Model
+  include HALPresenter::Serializer
+  include HALPresenter::Deserializer
+  include HALPresenter::Policy
+end
+
+# Keeping this module for backward compatibility!
+module HALDecorator
+  include HALPresenter
+
+  def self.method_missing(m, *args, &block)
+    HALPresenter.send(m, *args, &block)
+  end
+end

data/lib/hal_presenter/attributes.rb

@@ -0,0 +1,27 @@
+require 'hal_presenter/property'
+
+module HALPresenter
+  module Attributes
+    def attribute(*args, &block)
+      @_attributes ||= init_attributes
+      @_attributes = @_attributes.reject { |attr| attr.name == args.first }
+      @_attributes << Property.new(*args, &block)
+    end
+
+    protected
+
+    def attributes
+      @_attributes ||= init_attributes
+    end
+
+    private
+
+    def init_attributes
+      return [] unless is_a? Class
+      return [] unless superclass.respond_to?(:attributes, true)
+      superclass.attributes.each do |attr|
+        attr.change_scope(self)
+      end
+    end
+  end
+end

data/lib/hal_presenter/collection.rb

@@ -0,0 +1,42 @@
+require 'hal_presenter/property'
+
+module HALPresenter
+  module Collection
+
+    class CollectionParameters
+      include Attributes
+      include Links
+      include Curies
+
+      attr_reader :name
+
+      def initialize(name, &block)
+        @name = name
+        instance_exec(&block) if block_given?
+      end
+    end
+
+    def collection(of:, &block)
+      @_parameters = CollectionParameters.new(of, &block)
+    end
+
+    protected
+
+    def collection_parameters
+      @_parameters ||= init_collection_params
+    end
+
+    def can_serialize_collection?
+      !collection_parameters.nil?
+    end
+
+    private
+
+    def init_collection_params
+      return unless is_a? Class
+      if superclass.respond_to?(:collection_parameters, true)
+        superclass.collection_parameters
+      end
+    end
+  end
+end

data/lib/hal_presenter/curies.rb

@@ -0,0 +1,30 @@
+require 'hal_presenter/property'
+
+module HALPresenter
+  module Curies
+    def curie(rel, value = nil, &block)
+      if value.nil? && !block_given?
+        raise 'curie must be called with non nil value or be given a block'
+      end
+      @_curies ||= init_curies
+      @_curies = @_curies.reject { |curie| curie.name == rel }
+      @_curies << Property.new(rel, value, &block)
+    end
+
+    protected
+
+    def curies
+      @_curies ||= init_curies
+    end
+
+    private
+
+    def init_curies
+      return [] unless is_a? Class
+      return [] unless superclass.respond_to?(:curies, true)
+      superclass.curies.each do |curie|
+        curie.change_scope(self)
+      end
+    end
+  end
+end

data/lib/hal_presenter/deserializer.rb

@@ -0,0 +1,91 @@
+require 'json'
+
+module HALPresenter
+
+  def self.from_hal(presenter, payload, resource = nil)
+    presenter.from_hal(payload, resource)
+  end
+
+  module Deserializer
+
+    class Error < StandardError; end
+
+    def from_hal(payload, resource = nil)
+      return if payload.nil? || payload.empty?
+      hash = JSON.parse(payload)
+      from_hash(hash, resource)
+    end
+
+    protected
+
+    def from_hash(hash, resource)
+      as_collection = deserialize_as_collection?(hash)
+
+      if resource.nil?
+        model = HALPresenter.lookup_model self
+        raise Error, "No model for #{self.class}" unless model
+        resource = as_collection ? [] : model.new
+      elsif as_collection
+        resource.clear
+      end
+
+      if as_collection
+        deserialize_collection(hash, resource)
+      else
+        deserialize_attributes(hash, resource)
+        deserialize_embedded(hash, resource)
+      end
+      resource
+    end
+
+    def deserialize_attributes(hash, resource)
+      attributes.each do |attribute|
+        setter_method = setter_method_name(attribute.name)
+        next unless resource.respond_to? setter_method
+        resource.public_send(setter_method, hash[attribute.name.to_s])
+      end
+    end
+
+    def deserialize_embedded(hash, resource)
+      embedded.each do |embed|
+        setter_method = setter_method_name(embed.name) or next
+        next unless resource.respond_to? setter_method
+        presenter = embed.presenter_class or next
+
+        embedded_hash = hash.dig('_embedded', embed.name.to_s)
+        next unless embedded_hash&.any?
+
+        embedded_resource = resource.public_send(embed.name)
+        embedded_resource = 
+          if embedded_hash.is_a? Array
+            embedded_hash.map { |h| presenter.from_hash(h, embedded_resource) }
+          else
+            presenter.from_hash(embedded_hash, embedded_resource)
+          end
+        resource.public_send(setter_method, embedded_resource)
+      end
+    end
+
+    def deserialize_collection(hash, resource)
+      hash['_embedded'][collection_parameters.name].each do |resource_hash|
+        resource << from_hash(resource_hash, nil)
+      end
+    end
+
+    private
+
+    def deserialize_as_collection?(hash)
+      name = collection_parameters&.name
+      # return true/false (Hash#key? returns nil if not found..)
+      name && hash['_embedded']&.key?(name) || false
+    end
+
+    def setter_method_name(attr)
+      "#{attr}=".to_sym
+    end
+
+  end
+end
+
+
+

data/lib/hal_presenter/embedded.rb

@@ -0,0 +1,36 @@
+require 'hal_presenter/property'
+
+module HALPresenter
+  module Embedded
+    class Embed < HALPresenter::Property
+      attr_reader :presenter_class
+
+      def initialize(name, value = nil, presenter_class: nil, &block)
+        super(name, value, &block)
+        @presenter_class = presenter_class
+      end
+    end
+
+    def embed(*args, &block)
+      @_embedded ||= init_embedded
+      @_embedded = @_embedded.reject { |embed| embed.name == args.first }
+      @_embedded << Embed.new(*args, &block)
+    end
+
+    protected
+
+    def embedded
+      @_embedded ||= init_embedded
+    end
+
+    private
+
+    def init_embedded
+      return [] unless is_a? Class
+      return [] unless superclass.respond_to?(:embedded, true)
+      superclass.embedded.each do |embed|
+        embed.change_scope(self)
+      end
+    end
+  end
+end

data/lib/hal_presenter/links.rb

@@ -0,0 +1,54 @@
+require 'hal_presenter/property'
+
+module HALPresenter
+
+  def self.base_href=(base)
+    @base_href = base&.sub(%r(/*$), '')
+  end
+
+  def self.href(href)
+    return href if (@base_href ||= '').empty?
+    return href if href =~ %r(\A(\w+://)?[^/])
+    @base_href + href
+  end
+
+  module Links
+
+    class Link < HALPresenter::Property
+      attr_reader :http_method
+      def initialize(rel, value = nil, http_method: nil, &block)
+        if value.nil? && !block_given?
+          raise 'link must be called with non nil value or be given a block'
+        end
+        @http_method = http_method
+        super(rel, value, &block)
+      end
+
+      def rel
+        name
+      end
+    end
+
+    def link(rel, value = nil, method: nil, methods: nil, &block)
+      @_links ||= init_links
+      @_links = @_links.reject { |link| link.rel == rel }
+      @_links << Link.new(rel, value, http_method: method || methods, &block)
+    end
+
+    protected
+
+    def links
+      @_links ||= init_links
+    end
+
+    private
+
+    def init_links
+      return [] unless is_a? Class
+      return [] unless superclass.respond_to?(:links, true)
+      superclass.links.each do |link|
+        link.change_scope(self)
+      end
+    end
+  end
+end

data/lib/hal_presenter/model.rb

@@ -0,0 +1,35 @@
+module HALPresenter
+  @presenters = {}
+
+  def HALPresenter.register(model:, presenter:)
+    @presenters[presenter] = model
+  end
+
+  def HALPresenter.unregister(presenter)
+    @presenters.delete_if { |d,_| d == presenter }
+  end
+
+  def HALPresenter.lookup_model(presenter)
+    @presenters[presenter]
+  end
+
+  def HALPresenter.lookup_presenter(model)
+    clazz = model.is_a?(Class) ? model : model.class
+    presenters = @presenters.select { |d, m| m == clazz }.keys.compact
+    presenters.empty? ? nil : presenters
+  end
+
+  module Model
+    def model(clazz)
+      HALPresenter.register(model: clazz, presenter: self)
+    end
+
+    def inherited(subclass)
+      if model = HALPresenter.lookup_model(self)
+        HALPresenter.register(model: model, presenter: subclass)
+      end
+      super
+    end
+  end
+end
+

data/lib/hal_presenter/pagination.rb

@@ -0,0 +1,126 @@
+module HALPresenter
+  class << self
+    attr_accessor :paginate
+  end
+
+  # TODO: Support Kaminari and Will_paginate
+ 
+  class Pagination
+
+    class Uri
+      def self.parse(str)
+        uri = nil
+        query = nil
+        unless str.nil? || str.empty?
+          if m = str.match(%r(\A([^\?]+)\??([^\#]+)?.*\Z))
+            uri = m[1]
+            query = query_from_string m[2]
+          end
+        end
+        new(uri, query)
+      end
+
+      def self.query_from_string(str)
+        return {} if str.nil? || str.empty?
+        str.split('&').each_with_object({}) do |pair, q|
+          key_value = pair.split('=')
+          q[key_value[0]] = key_value[1];
+        end
+      end
+
+      def initialize(uri, query)
+        @uri = uri
+        @query = query
+      end
+
+      def +(query)
+        self.class.new(@uri, @query.merge(query))
+      end
+
+      def to_s
+        return if @uri.nil?
+        @uri.dup.tap do |uri|
+          next if @query.nil? || @query.empty?
+          uri << "?" + @query.map { |k,v| "#{k}=#{v}" }.join('&')
+        end
+      end
+    end
+
+    def self.paginate!(serialized, collection)
+      new(serialized, collection).call
+    end
+
+    def initialize(serialized, collection)
+      @serialized = serialized
+      @collection = collection
+      @self_uri = Uri.parse serialized.dig(:_links, :self, :href)
+    end
+
+    def call
+      return unless should_paginate?
+      add_query_to_self
+      add_prev_link
+      add_next_link
+    end
+
+    private
+
+    attr_accessor :serialized, :collection, :self_uri
+
+    def should_paginate?
+      self_uri && current_page
+    end
+
+    def query(page)
+      return {} unless page
+      {
+        page: page,
+        per_page: per_page,
+      }
+    end
+
+    def add_query_to_self
+      serialized[:_links][:self][:href] = (self_uri + query(current_page)).to_s
+    end
+
+    def add_prev_link
+      return if serialized[:_links][:prev] || !prev_page
+      serialized[:_links][:prev] = {
+        href: (self_uri + query(prev_page)).to_s
+      }
+    end
+
+    def add_next_link
+      return if serialized[:_links][:next] || !next_page
+      serialized[:_links][:next] = {
+        href: (self_uri + query(next_page)).to_s
+      }
+    end
+
+    # Supported by Sequel, Kaminari and will_paginate
+    def current_page
+      collection.respond_to?(:current_page) && collection.current_page
+    end
+
+    def prev_page
+      return collection.prev_page if collection.respond_to?(:prev_page) # Sequel and Kaminari
+      return collection.previous_page if collection.respond_to?(:previous_page) # will_paginate
+    end
+
+    # Supported by Sequel, Kaminari and will_paginate
+    def next_page
+      collection.respond_to?(:next_page) && collection.next_page
+    end
+
+    def per_page
+      if collection.respond_to?(:page_size)
+        collection.page_size # Supported by Sequel
+      elsif collection.respond_to?(:max_per_page)
+        collection.max_per_page # Supported by Kaminari
+      elsif collection.respond_to?(:per_page)
+        collection.per_page # Supported by will_paginate
+      end
+    end
+  end
+end
+

data/lib/hal_presenter/policy.rb

@@ -0,0 +1,22 @@
+module HALPresenter
+  module Policy
+
+    def policy(clazz)
+      @_policy = clazz
+    end
+
+    protected
+
+    def policy_class
+      @_policy ||= init_policy
+    end
+
+    private
+
+    def init_policy
+      return unless is_a? Class
+      return unless superclass.respond_to?(:policy_class, true)
+      superclass.policy_class
+    end
+  end
+end

data/lib/hal_presenter/policy/dsl.rb

@@ -0,0 +1,112 @@
+module HALPresenter
+  module Policy
+    module DSL
+
+      class Rules
+
+        def attributes
+          @attributes ||= Hash.new(Proc.new { false })
+        end
+
+        def links
+          @links ||= Hash.new(Proc.new { false })
+        end
+
+        def embedded
+          @embedded ||= Hash.new(Proc.new { false })
+        end
+
+        private :attributes, :links, :embedded
+
+        def defaults(*types, value: false)
+          types.each do |t|
+            send(t).default= Proc.new { value }
+          end
+        end
+
+        def attribute_rule_for(name)
+          attributes[name]
+        end
+
+        def add_attribute(name, block)
+          attributes[name] = block
+        end
+
+        def link_rule_for(rel)
+          links[rel]
+        end
+
+        def add_link(rel, block)
+          links[rel] = block
+        end
+
+        def embed_rule_for(name)
+          embedded[name]
+        end
+
+        def add_embed(name, block)
+          embedded[name] = block
+        end
+
+      end
+
+      module ClassMethods
+
+        def allow_by_default(*types)
+          rules.defaults(*types, value: true)
+        end
+
+        def attribute(*names)
+          b = block_given? ? Proc.new : Proc.new { true }
+          names.each { |name| rules.add_attribute(name, b) }
+        end
+
+        def link(*rels)
+          b = block_given? ? Proc.new : Proc.new { true }
+          rels.each { |rel| rules.add_link(rel, b) }
+        end
+
+        def embed(*names)
+          b = block_given? ? Proc.new : Proc.new { true }
+          names.each { |name| rules.add_embed(name, b) }
+        end
+
+        def rules
+          @rules ||= Rules.new
+        end
+
+      end
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      def initialize(current_user, resource, options = {})
+        @current_user = current_user
+        @resource = resource
+        @options = options
+      end
+
+      def attribute?(name)
+        run self.class.rules.attribute_rule_for(name)
+      end
+
+      def link?(rel)
+        run self.class.rules.link_rule_for(rel)
+      end
+
+      def embed?(name)
+        run self.class.rules.embed_rule_for(name)
+      end
+
+      private
+
+      attr_reader :current_user, :resource, :options
+
+      def run(block)
+        instance_eval(&block) && true || false
+      end
+
+    end
+  end
+end

data/lib/hal_presenter/property.rb

@@ -0,0 +1,57 @@
+module HALPresenter
+  class Property
+    attr_reader :name, :resource, :options
+
+    alias :resources :resource
+
+    def initialize(name, value = nil, &block)
+      @name = name
+      @value = value
+      @scope = nil
+      return unless block_given?
+      @scope = eval 'self', block.binding
+      define_singleton_method(:value_from_block, &block)
+    end
+
+    def value(resource = nil, options = {})
+      @resource = resource
+      @options = options
+      if scope
+        value_from_block
+      elsif resource && @value.nil?
+        resource.public_send(name) if resource.respond_to?(name)
+      else
+        @value
+      end
+    ensure
+      reset
+    end
+
+    def change_scope(new_scope)
+      return unless scope
+      @scope = new_scope
+    end
+
+    def method_missing(method, *args, &block)
+      if scope&.respond_to? method
+        define_singleton_method(method) { |*a, &b| scope.public_send method, *a, &b }
+        return public_send(method, *args, &block)
+      end
+      super
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      return true if scope&.respond_to? method
+      super
+    end
+
+    private
+
+    attr_reader :scope
+
+    def reset
+      @resource = nil
+      @options = nil
+    end
+  end
+end

data/lib/hal_presenter/serialize_hooks.rb

@@ -0,0 +1,41 @@
+require 'hal_presenter/property'
+
+module HALPresenter
+  module SerializeHooks
+
+    class Hook
+      attr_reader :name, :resource, :options
+
+      def initialize(&block)
+        @block = block
+      end
+
+      def run(resource, options, arg)
+        @resource = resource
+        @options = options
+        instance_exec(arg, &@block) if @block
+      ensure
+        @resource = nil
+        @options = nil
+      end
+    end
+
+    def post_serialize(&block)
+      @_post_serialize_hook = Hook.new(&block)
+    end
+
+    protected
+
+    def post_serialize_hook
+      @_post_serialize_hook ||= init_post_serialize_hook
+    end
+
+    private
+
+    def init_post_serialize_hook
+      return unless is_a? Class
+      return unless superclass.respond_to?(:post_serialize_hook, true)
+      superclass.post_serialize_hook
+    end
+  end
+end

data/lib/hal_presenter/serializer.rb

@@ -0,0 +1,162 @@
+require 'json'
+require 'hal_presenter/pagination'
+
+module HALPresenter
+
+  def self.to_hal(resource, options = {})
+    raise Serializer::Error, "Resource is nil" if resource.nil?
+    presenter = options.delete(:presenter)
+    presenter ||= HALPresenter.lookup_presenter(resource)&.last
+    raise Serializer::Error, "No presenter for #{resource}" unless presenter
+    presenter.to_hal(resource, options)
+  end
+
+  def self.to_collection(resources, options = {})
+    raise Serializer::Error, "resources is nil" if resources.nil?
+    presenter = options.delete(:presenter)
+    presenter ||= HALPresenter.lookup_presenter(resources.first)&.last
+    raise Serializer::Error, "No presenter for #{resources.first}" unless presenter
+    presenter.to_collection(resources, options)
+  end
+
+  module Serializer
+
+    class Error < StandardError; end
+
+    def to_hal(resource = nil, options = {})
+      hash = to_hash(resource, options)
+      JSON.generate(hash)
+    end
+
+    def to_collection(resources = [], options = {})
+      unless can_serialize_collection?
+        raise Error,
+          "Trying to serialize a collection using #{self} which has no collection info. " \
+          "Add a 'collection' spec to the serializer or use another serializer"
+      end
+      options[:paginate] = HALPresenter.paginate unless options.key? :paginate
+      hash = to_collection_hash(resources, options)
+      JSON.generate(hash)
+    end
+
+    protected
+
+    def to_hash(resource, options)
+      policy = policy_class&.new(options[:current_user], resource, options)
+
+      {}.tap do |serialized|
+        serialized.merge! serialize_attributes(resource, policy, options)
+        serialized.merge! serialize_links(resource, policy, options)
+        serialized.merge! serialize_embedded(resource, policy, options)
+
+        run_post_serialize_hook!(resource, options, serialized)
+      end
+    end
+
+    def to_collection_hash(resources, options)
+      parameters = collection_parameters
+      links = parameters.links
+      curies = parameters.curies
+      {}.tap do |serialized|
+        serialized.merge!  _serialize_attributes(parameters.attributes, resources, nil, options)
+        serialized.merge! _serialize_links(links, curies, resources, nil, options)
+        Pagination.paginate!(serialized, resources) if options[:paginate]
+
+        serialized_resources = resources.map { |resource| to_hash(resource, options) }
+        serialized[:_embedded] = { parameters.name => serialized_resources }
+      end
+    end
+
+    def serialize_attributes(resource, policy, options)
+      _serialize_attributes(attributes, resource, policy, options)
+    end
+
+    def serialize_links(resource, policy, options)
+      _serialize_links(links, curies, resource, policy, options)
+    end
+
+    def serialize_curies(resource, policy, options)
+      _serialize_curies(curies, resource, policy, options)
+    end
+
+    def serialize_embedded(resource, policy, options)
+      _serialize_embedded(embedded, resource, policy, options)
+    end
+
+    def run_post_serialize_hook!(resource, options, serialized)
+      hook = post_serialize_hook
+      hook&.run(resource, options, serialized)
+    end
+
+    private
+
+    def _serialize_attributes(attributes, resource, policy, options)
+      attributes.each_with_object({}) do |attribute, hash|
+        next if policy && !policy.attribute?(attribute.name)
+        hash[attribute.name] = attribute.value(resource, options)
+      end
+    end
+
+    def _serialize_links(links, curies, resource, policy, options)
+      serialized = links.each_with_object({}) do |link, hash|
+        next if policy && !policy.link?(link.rel)
+        href = link.value(resource, options) or next
+        hash[link.rel] = { href: HALPresenter.href(href) }.tap do |s|
+          s[:method] = link.http_method if link.http_method
+        end
+      end
+      curies = _serialize_curies(curies, resource, policy, options)
+      serialized[:curies] = curies if curies.any?
+      return {} if serialized.empty?
+      { _links: serialized }
+    end
+
+    def _serialize_curies(curies, resource, policy, options)
+      curies.each_with_object([]) do |curie, array|
+        next if policy && !policy.link?(curie.name)
+        href = curie.value(resource, options) or next
+        array << {
+          name: curie.name,
+          href: HALPresenter.href(href),
+          templated: true
+        }
+      end
+    end
+
+    def _serialize_embedded(embedded, object, policy, options)
+      serialized = embedded.each_with_object({}) do |embed, hash|
+        next if policy && !policy.embed?(embed.name)
+        resource = embed.value(object, options) or next
+        presenter = embed.presenter_class
+        hash[embed.name] = 
+          if resource.respond_to? :each
+            _serialize_embedded_collection(resource, presenter, options)
+          else
+            presenter ||= HALPresenter.lookup_presenter(resource).first
+            presenter.to_hash(resource, options)
+          end
+      end
+      return {} if serialized.empty?
+      { _embedded: serialized }
+    end
+
+    def _serialize_embedded_collection(resources, presenter, options)
+      clazz = resources.first.class
+      presenter ||= HALPresenter.lookup_presenter(clazz)&.first
+      if presenter.nil?
+        raise Serializer::Error,
+          "No presenter specified to handle serializing embedded #{clazz}"
+      end
+      if presenter.respond_to?(:can_serialize_collection?, true) &&
+          presenter.can_serialize_collection?
+        presenter.to_collection_hash(resources, options)
+      else
+        resources.map do |resrc|
+          presenter.to_hash(resrc, options)
+        end
+      end
+    end
+  end
+end
+
+

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: hal_presenter
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Sammy Henningsson
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDljCCAn6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBIMRowGAYDVQQDDBFzYW1t
+  eS5oZW5uaW5nc3NvbjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+  LGQBGRYDY29tMB4XDTE3MDcwODE0MDUxOVoXDTE4MDcwODE0MDUxOVowSDEaMBgG
+  A1UEAwwRc2FtbXkuaGVubmluZ3Nzb24xFTATBgoJkiaJk/IsZAEZFgVnbWFpbDET
+  MBEGCgmSJomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+  ggEBAK+SDC1mfyhucJ6Va21rIHUGscEtQrdvyBqxFG1s2TgPMAv4RbqwdJVPa7kj
+  tbCzslADlUE1oru2C+rcJsMtVGX02ukMIPHT1OjTyy0/EMqLqSy3WeRI8APyDSxC
+  Vbe+h5BMf3zZnYfddR6AeG7ln09T1P/tX+9lTMc+I+DW1fUlQgY48CNUayvtJR61
+  svXvXMrhLhi29SQig1qmH6Zoe22/JgH+m2JksPndY5Ep3gqfDc6Imwu2vGvmGErJ
+  D63FB0XQ/wb4WVH4l7sHQSTfKDp8SImCt1xqNgIyjw578ZG2geGLoncuxgDrbQ/U
+  FIJ11lDZd4vLevMhnIxTSJpPr2cCAwEAAaOBijCBhzAJBgNVHRMEAjAAMAsGA1Ud
+  DwQEAwIEsDAdBgNVHQ4EFgQUukjj1Cd2ea6IOHDLZe0ymzs2jWkwJgYDVR0RBB8w
+  HYEbc2FtbXkuaGVubmluZ3Nzb25AZ21haWwuY29tMCYGA1UdEgQfMB2BG3NhbW15
+  Lmhlbm5pbmdzc29uQGdtYWlsLmNvbTANBgkqhkiG9w0BAQUFAAOCAQEAGBReofO0
+  CDGI8uQNn/btde+zQBiCX0mONJMQ6An760MzOHMlWFi6VaVeeKmYj5xCpI2nWaJN
+  49ALW/v7GZ+JIW5YmbzWIuD8YfwHJYCFPoH0llzg3GCFCMxbYqI3nDtHX3dMxpOc
+  01A72okERe0ne/O5Z4Ym/fOECkyXr0fYondhDQcSuqxU22jsXs1ZjISN8IuHmVkA
+  GtGteOIqmA05lP+eCXGvyARGLg1GwZDTjnlH5OfpiT1Oy7Dghewi58Gn4/AlZ4bY
+  CNZdF8Vavp6xMQbPHZwqjaeZz2WRXYS7jyYSvCunjwa3OtvXtfbIEGEWE6IM+t9k
+  H1g6Q+B6qk9O6g==
+  -----END CERTIFICATE-----
+date: 2018-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+- !ruby/object:Gem::Dependency
+  name: will_paginate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.6
+description: |
+  A DSL for serializing resources according to
+  HypertextApplicationLanguage.
+email: sammy.henningsson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hal_presenter.rb
+- lib/hal_presenter/attributes.rb
+- lib/hal_presenter/collection.rb
+- lib/hal_presenter/curies.rb
+- lib/hal_presenter/deserializer.rb
+- lib/hal_presenter/embedded.rb
+- lib/hal_presenter/links.rb
+- lib/hal_presenter/model.rb
+- lib/hal_presenter/pagination.rb
+- lib/hal_presenter/policy.rb
+- lib/hal_presenter/policy/dsl.rb
+- lib/hal_presenter/property.rb
+- lib/hal_presenter/serialize_hooks.rb
+- lib/hal_presenter/serializer.rb
+homepage: https://github.com/sammyhenningsson/hal_presenter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: HAL serializer
+test_files: []

metadata.gz.sig

@@ -0,0 +1,3 @@
+�Bsv��wJ�����T���=��f@�����]|���3�n�e-i��M���r�sE���$��
+�x�]�ĥ#
+s<���E��w���1�OI���mz2