ams_hal 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77898f307f89b2c0e0817b60c5837161cbdb387d
+  data.tar.gz: 29abc151fe345ab914679e56e5dda53b3d77352d
+SHA512:
+  metadata.gz: 4ebacd405a3634d4a3a9a1379e7efb20f446a6b313788f3735758675b659d2e8824cc45b02c9c4131faf2a7004f03000e4468b078a5d0ae0692e27742b57e00f
+  data.tar.gz: 768689cfd85cc23962255f5a00cd959d8f5df3a7212158c11c89064ffa098f53bd1303251510150271ee9708696092b35962be1b1f805985f3b4ddb15cfbad1a

data/lib/ams_hal.rb

@@ -0,0 +1,7 @@
+require 'active_support/core_ext/hash/indifferent_access.rb'
+require 'active_model_serializers'
+require 'ams_hal/adapter'
+require 'ams_hal/link'
+require 'ams_hal/curies'
+require 'ams_hal/embedded'
+require 'ams_hal/embed'

data/lib/ams_hal/adapter.rb

@@ -0,0 +1,131 @@
+module AmsHal
+  class Adapter < ActiveModelSerializers::Adapter::Base
+    def serializable_hash(options = nil)
+      options = serialization_options(options)
+      options[:fields] ||= instance_options[:fields]
+      serialized = if serializer.respond_to?(:each)
+                     serializer.each_with_object([]) do |_serializer, array|
+                       array << serialize_resource(_serializer, instance_options, options)
+                     end
+                   else
+                     serialize_resource(serializer, instance_options, options)
+                   end
+
+      self.class.transform_key_casing!(serialized, instance_options)
+    end
+
+    protected
+
+    def serialize_resource(serializer, adapter_options, options)
+      options[:include_directive] = {} # Don't include associations as attributes
+      serialized = serializer.serializable_hash(adapter_options, options, self)
+
+      if links = serialize_links(serializer)
+        serialized[:_links] = links if links.any?
+      end
+
+      if embedded = serialize_embedded(serializer)
+        serialized[:_embedded] = embedded if embedded.any?
+      end
+
+      if associations = serialize_associations(serializer)
+        serialized[:_embedded] = associations if associations.any?
+      end
+
+      serialized
+    end
+
+    def serialize_links(serializer)
+      return unless serializer.respond_to? :_links
+      links = serializer._links.each_with_object({}) do |(rel, value), hash|
+        link = Link.new(serializer, value).value
+        [link].flatten.each do |href|
+          next unless href
+          if hash.key? rel
+            hash[rel] = [hash[rel]] unless hash[rel].is_a? Array
+            hash[rel] << { href: href }
+          else
+            hash[rel] = { href: href }
+          end
+        end
+      end
+      curies = serialize_curies(serializer)
+      links[:curies] = curies if curies
+
+      links
+    end
+
+    def serialize_curies(serializer)
+      return unless serializer.respond_to? :curies
+      serializer.curies.each_with_object([]) do |(name, value), array|
+        href = Link.new(serializer, value).value
+        array << {
+          name: name,
+          href: href,
+          templated: true
+        }
+      end
+    end
+
+    def serialize_embedded(serializer)
+      return unless serializer.respond_to? :embedded
+      serializer.embedded.each_with_object({}) do |embed, embedded|
+        resource = embed.resource_for(serializer)
+
+        next unless resource
+
+        serialized_resources = [resource].flatten.map do |resrc|
+          serialize_embedded_resource(resrc)
+        end
+        embedded[embed.name] = if serialized_resources.size == 1
+                                  serialized_resources.first
+                                else
+                                  serialized_resources
+                                end
+      end
+    end
+
+    def serialize_associations(serializer)
+      serializer.associations.each_with_object({}) do |association, embedded|
+        object = serializer.object
+        if object&.respond_to? association.name
+          resource = object.public_send(association.name)
+        else
+          puts "WARN: Failed to get '#{association.name}' association from resource (#{object})"
+        end
+
+        next unless resource
+
+        if association.serializer.is_a? ActiveModel::Serializer::CollectionSerializer
+          # Not sure if this could happen and perhaps we should fail instead of create an array??
+          resource = [resource] unless resource.respond_to? :each
+
+          embedded[association.name] = resource.map do |resrc|
+            # FIXME: How to improve this?
+            serialize_embedded_resource(
+              resrc,
+              serializer: association.serializer.send(:options)[:serializer]
+            )
+          end
+        else
+          embedded[association.name] = serialize_embedded_resource(
+            resource, 
+            serializer: association.serializer&.class
+          )
+        end
+      end
+    end
+
+    private
+
+    def serialize_embedded_resource(resource, serializer: nil)
+      serializable_resource = ActiveModelSerializers::SerializableResource.new(
+        resource,
+        serializer: serializer,
+        adapter: AmsHal::Adapter
+      )
+      serializable_resource.as_json
+    end
+
+  end
+end

data/lib/ams_hal/curies.rb

@@ -0,0 +1,28 @@
+module AmsHal
+  module Curies
+
+    def self.included(base)
+      base.extend ClassMethods
+      base._curies = {}
+    end
+
+    module ClassMethods
+      attr_accessor :_curies
+
+      def inherited(subclass)
+        super
+        subclass._curies = _curies.dup
+      end
+
+      def curie(name, value = nil, &block)
+        _curies[name] = block || value
+      end
+    end
+
+    def curies
+      self.class._curies.dup
+    end
+
+  end
+end
+

data/lib/ams_hal/embed.rb

@@ -0,0 +1,38 @@
+require 'active_model_serializers/serialization_context'
+
+module AmsHal
+  class Embed
+    include ActiveModelSerializers::SerializationContext::UrlHelpers
+
+    attr_reader :name, :options
+
+    def initialize(serializer, name, options = {}, &block)
+      @name = name
+      @options = options
+      @block = block
+    end
+
+    def resource_for(serializer)
+      @object = serializer.object
+      @scope = serializer.scope
+
+      @self_before_instance_eval = nil
+      # Use the return value of the block unless it is nil.
+      if @block
+        @self_before_instance_eval = eval "self", @block.binding
+        @resource = instance_eval(&@block)
+      else
+        @resource = @object.public_send(name)
+      end
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      return super unless @self_before_instance_eval
+      @self_before_instance_eval.send method, *args, &block
+    end
+
+    attr_reader :object, :scope
+  end
+end

data/lib/ams_hal/embedded.rb

@@ -0,0 +1,28 @@
+module AmsHal
+  module Embedded
+
+    def self.included(base)
+      base.extend ClassMethods
+      base._embedded = []
+    end
+
+    module ClassMethods
+      attr_accessor :_embedded
+
+      def inherited(subclass)
+        super
+        subclass._embedded = _embedded.dup
+      end
+
+      def embed(name, options = {}, &block)
+        self._embedded << Embed.new(self, name, options, &block)
+      end
+    end
+
+    def embedded
+      self.class._embedded.dup
+    end
+
+  end
+end
+

data/lib/ams_hal/link.rb

@@ -0,0 +1,31 @@
+require 'active_model_serializers/serialization_context'
+
+module AmsHal
+  class Link
+    include ActiveModelSerializers::SerializationContext::UrlHelpers
+
+    attr_reader :value
+
+    def initialize(serializer, value)
+      @object = serializer.object
+      @scope = serializer.scope
+      @self_before_instance_eval = nil
+      # Use the return value of the block unless it is nil.
+      if value.respond_to?(:call)
+        @self_before_instance_eval = eval "self", value.binding
+        @value = instance_eval(&value)
+      else
+        @value = value
+      end
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      return super unless @self_before_instance_eval
+      @self_before_instance_eval.send method, *args, &block
+    end
+
+    attr_reader :object, :scope
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: ams_hal
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Sammy Henningsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_model_serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.5
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Provides an adapter to use with ActiveModel::Serializer
+  so that resources can be serializer according to
+  HypertextApplicationLanguage.
+email: sammy.henningsson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ams_hal.rb
+- lib/ams_hal/adapter.rb
+- lib/ams_hal/curies.rb
+- lib/ams_hal/embed.rb
+- lib/ams_hal/embedded.rb
+- lib/ams_hal/link.rb
+homepage: https://github.com/sammyhenningsson/ams_hal
+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.6.8
+signing_key: 
+specification_version: 4
+summary: HAL adapter for active_model_serializers
+test_files: []