simple_ams 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5193c4f1997cfc84c8fdf5fa90abfde7ac2a03a2
-  data.tar.gz: 13c6c665417899d0a73d9900144d58e8f848e370
+  metadata.gz: 402b318569b32a747756164ace5901543dfae101
+  data.tar.gz: 9cad887a5be00d87011f12a55bb779084d51e147
 SHA512:
-  metadata.gz: b6affb011516c6e9b69b829c176966305b38f7d102b874248bac63fb089c8b84b27cec6190e067364943935b26164bcc066d12ebad77c88d412edaf7db6724aa
-  data.tar.gz: c44a84ff86b1a0d2eb5b67670b508a3cfa6da2ded1cc0353fd0709b73a352a7a2d1bf735860cba76ae03f696e4eefab50c4704b67229be8fb1285f43376c8ea2
+  metadata.gz: 5ad0ca8cfb422fedbf1ddc2b8d2d3f3150b9c704a20720c83f7aa81ccb03e913edf2c2e52f15a13307e0eb2b8c3ded26e620ffc2fc5650f0c195f6b95c385431
+  data.tar.gz: d35104e20592ff6b54235a7d990875737c454079ece2dd267530d9831eecc6c1d6a470152b7bc0daf36fd3cebafecf2d2e6d46d564a32253c332a243dd605fe1

data/.gitignore

@@ -12,3 +12,4 @@
 # rspec failure tracking
 .rspec_status
 .todo.md
+*.gem

data/README.md

@@ -41,9 +41,17 @@ class UserSerializer
   attributes :id, :name, :email, :birth_date
 
   #specify available relations
-  has_many :videos, :comments, :posts
-  belongs_to :organization
-  has_one :profile
+  has_one :profile, serializer: ProfileSerializer
+  #belongs_to is just an alias to has_one
+  belongs_to :organization, serializer: OrganizationSerializer
+  has_many :videos, serializer: VideosSerializer
+    #rarely used: if you need more options, you can pas a block
+    #which adheres to the same DSL as described here
+    #it goes to an option called `embedded`
+    #essentially these options here should be used for linking current resource
+    #with the relation (useful for JSONAPI for instance)
+    generic :include_data, false
+  end
 
   #specify some links
   link :feed, '/api/v1/me/feed'
@@ -57,16 +65,26 @@ class UserSerializer
   #same with metas: can be static, dynamic and accept arbitrary options
   meta :environment, ->(obj) { Rails.env.to_s }
 
-  #collection accepts exactly the same aforementioned interface
-  #although you will rarely use it to full extend
-  #here we use only links and meta
+  #same with form: can be static, dynamic and accept arbitrary options
+  form :create, ->(obj) { User::CreateForm.for(obj) }
+
+  #or if you need something quite generic (and probably adapter-related)
+  #again it follows the same patterns as link
+  generic :include_embedded_data, true, {only: :collection}
+
+  #these are properties to the collection resource itself
+  #AND NOT to each resource separately, when applied inside a collection..
+  #It's a rarely used feature but definitely nice to have..
   collection do
+    #collection accepts exactly the same aforementioned interface
+    #here we use only links and meta
     link :root, '/api/v1/', rel: :user
     type :users
     meta :count, ->(collection) { collection.count }
   end
 
-  #note that there is a shortcut if you just need to specify the collection name/type:
+  #note that most probably the only thing that you will need here is the `type`,
+  #so there is a shortcut if you just need to specify the collection name/type:
   #collection :users
 
   #override an attribute
@@ -146,6 +164,11 @@ In any case, we have the following options:
     #meta can take arbitrary options as well
     authorization: :oauth, type: :bearer_token
   },
+  #the form data, same as the links/metas data (available in adapters even for single records)
+  forms: {
+    update: ->(obj){ User::UpdateForm.for(obj)}
+    follow: ->(obj){ User::FollowForm.for(obj)}
+  },
   #collection parameters, used only in ArrayRenderer
   collection: {
     links: {
@@ -158,6 +181,10 @@ In any case, we have the following options:
       next_page: ->(obj) { [obj.next_page, collection: true] },
       max_per_page: 50,
     },
+    #creating a resource goes in the collection route (users/), hence inside collection options ;)
+    forms: {
+      create: ->(obj){ User::CreateForm.for(obj)}
+    },
   }
   #exposing helpers that will be available inside the seriralizer
   expose: {
@@ -206,8 +233,8 @@ SimpleAMS::Renderer.new(user, {
   #   ...
   #   ...
 }).to_json
-
 ```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/simple_ams/adapters/ams.rb

@@ -11,45 +11,52 @@ class SimpleAMS::Adapters::AMS
   def as_json
     hash = {}
 
-    #TODO: I think bang method for merging is way faster ?
-    hash = hash.merge(fields)
-    hash = hash.merge(relations)
-    hash = hash.merge(links: links) unless links.empty?
-    hash = hash.merge(metas: metas) unless metas.empty?
+    hash.merge!(fields)
+    hash.merge!(relations) unless relations.empty?
+    hash.merge!(links: links) unless links.empty?
+    hash.merge!(metas: metas) unless metas.empty?
+    hash.merge!(forms: forms) unless forms.empty?
 
+    return {document.name => hash} if options[:root]
     return hash
   end
 
   def fields
     @fields ||= document.fields.inject({}){ |hash, field|
-      _value = field.value
-      hash[field.key] = _value.respond_to?(:as_json) ? _value.as_json : _value
+      hash[field.key] = field.value
       hash
     }
   end
 
   def links
+    return @links ||= {} if document.links.empty?
+
     @links ||= document.links.inject({}){ |hash, link|
-      _value = link.value
-      hash[link.name] = _value.respond_to?(:as_json) ? _value.as_json : _value
+      hash[link.name] = link.value
       hash
     }
   end
 
   def metas
     @metas ||= document.metas.inject({}){ |hash, meta|
-      _value = meta.value
-      hash[meta.name] = _value.respond_to?(:as_json) ? _value.as_json : _value
+      hash[meta.name] = meta.value
+      hash
+    }
+  end
+
+  def forms
+    @forms ||= document.forms.inject({}){ |hash, form|
+      hash[form.name] = form.value
       hash
     }
   end
 
   def relations
-    return {} if document.relations.empty?
+    return @relations = {} if document.relations.available.empty?
 
-    @relations ||= document.relations.inject({}){ |hash, relation|
+    @relations ||= document.relations.available.inject({}){ |hash, relation|
       if relation.folder?
-        value = relation.documents.map{|doc| self.class.new(doc).as_json}
+        value = relation.map{|doc| self.class.new(doc).as_json}
       else
         value = self.class.new(relation).as_json
       end
@@ -70,16 +77,26 @@ class SimpleAMS::Adapters::AMS
 
     def as_json
       if options[:root]
-        {folder.name => documents}
+        {
+          folder.name => documents,
+          meta: metas
+        }
       else
         documents
       end
     end
 
     def documents
-      return folder.documents.map{|document|
+      return folder.map{|document|
         adapter.new(document).as_json
       } || []
     end
+
+    def metas
+      @metas ||= folder.metas.inject({}){ |hash, meta|
+        hash[meta.name] = meta.value
+        hash
+      }
+    end
   end
 end

data/lib/simple_ams/adapters/jsonapi.rb

@@ -0,0 +1,182 @@
+require "simple_ams"
+
+class SimpleAMS::Adapters::JSONAPI
+  DEFAULT_OPTIONS = {
+    skip_id_in_attributes: true
+  }
+
+  attr_reader :document, :options
+  def initialize(document, options = {})
+    @document = document
+    @options = DEFAULT_OPTIONS.merge(options)
+  end
+
+  def as_json
+    hash = {
+      data: data,
+    }
+
+    hash.merge!(links: links) unless links.empty?
+    hash.merge!(metas: metas) unless metas.empty?
+    hash.merge!(included: included) unless included.empty?
+
+    return hash
+  end
+
+  def data
+    data = {
+      transform_key(document.primary_id.name) => document.primary_id.value.to_s,
+      type: document.type.value,
+      attributes: fields,
+    }
+
+    data.merge!(relationships: relationships) unless relationships.empty?
+
+    data
+  end
+
+  def fields
+    @fields ||= document.fields.inject({}){ |hash, field|
+      unless options[:skip_id_in_attributes] && field_is_primary_id?(field)
+        hash[transform_key(field.key)] = field.value
+      end
+      hash
+    }
+  end
+
+  def transform_key(key)
+    key.to_s.gsub('_', '-')
+  end
+
+  def relationships
+    return @relationships ||= {} if document.relations.empty?
+
+    @relationships ||= document.relations.inject({}){ |hash, relation|
+      _hash = {}
+      embedded_relation_data = embedded_relation_data_for(relation)
+      unless embedded_relation_data.empty?
+        _hash.merge!(data: embedded_relation_data_for(relation))
+      end
+
+      embedded_relation_links = embedded_relation_links_for(relation)
+      unless embedded_relation_links.empty?
+        _hash.merge!(links: embedded_relation_links_for(relation))
+      end
+
+      hash.merge!(relation.name => _hash) unless _hash.empty?
+      hash
+    }
+  end
+
+  def embedded_relation_data_for(relation)
+    return {} if relation.embedded.generics[:skip_data]&.value
+
+    if relation.folder?
+      value = relation.documents.map{|doc|
+        {
+          doc.primary_id.name => doc.primary_id.value.to_s,
+          type: doc.type.name
+        }
+      }
+    else
+      value = {
+        relation.primary_id.name => relation.primary_id.value.to_s,
+        type: relation.type.name
+      }
+    end
+  end
+
+  def embedded_relation_links_for(relation)
+    return {} if relation.embedded.links.empty?
+
+    relation.embedded.links.inject({}){ |hash, link|
+      hash[link.name] = link.value
+      hash
+    }
+  end
+
+
+  def links
+    return @links ||= {} if document.links.empty?
+
+    @links ||= document.links.inject({}){ |hash, link|
+      hash[link.name] = link.value
+      hash
+    }
+  end
+
+  def metas
+    @metas ||= document.metas.inject({}){ |hash, meta|
+      hash[meta.name] = meta.value
+      hash
+    }
+  end
+
+  def forms
+    @forms ||= document.forms.inject({}){ |hash, form|
+      hash[form.name] = form.value
+      hash
+    }
+  end
+
+  def included
+    return @included ||= [] if document.relations.available.empty?
+
+    @included ||= document.relations.available.inject([]){ |array, relation|
+      if relation.folder?
+        array << relation.map{|doc| self.class.new(doc).as_json[:data]}
+      else
+        array << self.class.new(relation).as_json[:data]
+      end
+
+      array
+    }.flatten
+  end
+
+  class Collection < self
+    attr_reader :folder, :adapter, :options
+
+    def initialize(folder, options = {})
+      @folder = folder
+      @adapter = folder.adapter.value
+      @options = options
+    end
+
+    def as_json
+      hash = {
+        data: documents
+      }
+      hash.merge!(meta: metas) unless metas.empty?
+      hash.merge!(links: links) unless links.empty?
+
+      return hash
+    end
+
+    def documents
+      return folder.map{|document|
+        adapter.new(document).as_json[:data]
+      } || []
+    end
+
+    def metas
+      @metas ||= folder.metas.inject({}){ |hash, meta|
+        hash[transform_key(meta.name)] = meta.value
+        hash
+      }
+    end
+
+    def links
+      @links ||= folder.links.inject({}){ |hash, link|
+        hash[transform_key(link.name)] = link.value
+        hash
+      }
+    end
+  end
+
+  private
+    def field_is_primary_id?(field)
+      field.key == document.primary_id.name
+    end
+
+end
+

data/lib/simple_ams/document/fields.rb

@@ -4,7 +4,7 @@ module SimpleAMS
   class Document::Fields
     include Enumerable
 
-    attr_reader :members
+    Field = Struct.new(:key, :value)
 
     def initialize(options)
       @options = options
@@ -15,52 +15,37 @@ module SimpleAMS
       found = members.find{|field| field == key}
       return nil unless found
 
-      return with_decorator(found)
+      value_of(found)
     end
 
+    #TODO: Can we make this faster?
     def each(&block)
       return enum_for(:each) unless block_given?
 
       members.each{ |key|
-        yield with_decorator(key)
+        yield value_of(key)
       }
 
       self
     end
 
-    private
-      attr_reader :options
-
-      def with_decorator(key)
-        Field.new(
-          options.resource,
-          options.serializer,
-          key,
-          options
-        )
-      end
-
-      class Field
-        attr_reader :key
+    def any?
+      members.any?
+    end
 
-        #do we need to inject the whole options object?
-        def initialize(resource, serializer, key, options)
-          @resource = resource
-          @serializer = serializer
-          @key = key
-          @options = options
-        end
+    def empty?
+      members.empty?
+    end
 
-        def value
-          return @value if defined?(@value)
+    private
+      attr_reader :members, :options
 
-          return @value = serializer.send(key) if serializer.respond_to? key
-          binding.pry if resource.is_a?(Array)
-          return resource.send(key)
+      def value_of(key)
+        if options.serializer.respond_to?(key)
+          Field.new(key, options.serializer.send(key))
+        else
+          Field.new(key, options.resource.send(key))
         end
-
-        private
-          attr_reader :resource, :serializer
       end
   end
 end

data/lib/simple_ams/document/forms.rb

@@ -0,0 +1,13 @@
+require "simple_ams"
+
+module SimpleAMS
+  class Document::Forms < Document::Links
+    def initialize(options)
+      @options = options
+      @members = options.forms
+    end
+
+    class Form < Document::Links::Link
+    end
+  end
+end

data/lib/simple_ams/document/generics.rb

@@ -0,0 +1,14 @@
+require "simple_ams"
+
+module SimpleAMS
+  class Document::Generics < Document::Links
+    def initialize(options)
+      @options = options
+      @members = options.generics
+    end
+
+    class Option < Document::Links::Link
+    end
+  end
+end
+

data/lib/simple_ams/document/links.rb

@@ -4,7 +4,7 @@ module SimpleAMS
   class Document::Links
     include Enumerable
 
-    attr_reader :members
+    Link = Struct.new(:name, :value, :options)
 
     def initialize(options)
       @options = options
@@ -28,33 +28,23 @@ module SimpleAMS
       self
     end
 
-    private
-      attr_reader :options
-
-      def with_decorator(link)
-        Link.new(link)
-      end
-
-      #memoization maybe ?
-      class Link
-        def initialize(link)
-          @link = link
-        end
+    def any?
+      members.any?
+    end
 
-        def name
-          link.name
-        end
+    def empty?
+      members.empty?
+    end
 
-        def value
-          link.respond_to?(:call) ? link.value.call : link.value
-        end
+    private
+      attr_reader :members, :options
 
-        def options
+      def with_decorator(link)
+        Link.new(
+          link.name,
+          link.respond_to?(:call) ? link.value.call : link.value,
           link.options
-        end
-
-        private
-          attr_reader :link
+        )
       end
   end
 end

data/lib/simple_ams/document/metas.rb

@@ -3,7 +3,7 @@ require "simple_ams"
 module SimpleAMS
   class Document::Metas < Document::Links
     def initialize(options)
-      super
+      @options = options
       @members = options.metas
     end
 

data/lib/simple_ams/document/primary_id.rb

@@ -0,0 +1,23 @@
+module SimpleAMS
+  class Document::PrimaryId
+    attr_reader :name
+
+    def initialize(options)
+      @options = options
+      @name = options.primary_id.name
+    end
+
+    def value
+      if @options.serializer.respond_to?(name)
+        @options.serializer.send(name)
+      else
+        @options.resource.send(name)
+      end
+    end
+
+    def options
+      @options.primary_id.options
+    end
+  end
+end
+

data/lib/simple_ams/document/relations.rb

@@ -5,9 +5,9 @@ module SimpleAMS
   class Document::Relations
     include Enumerable
 
-    def initialize(options)
+    def initialize(options, relations)
       @options = options
-      @relations = options.relations
+      @relations = relations
       @serializer = options.serializer
       @resource = options.resource
     end
@@ -33,13 +33,29 @@ module SimpleAMS
       count == 0
     end
 
+    def available
+      return @available ||= [] if relations.available.empty?
+
+      @available ||= self.class.new(options, relations.available)
+    end
+
     private
       attr_reader :options, :relations, :serializer, :resource
 
       def relation_for(relation)
-        renderer_klass_for(relation).new(
+        relation_value = relation_value_for(relation.name)
+
+        renderer_klass_for(relation, relation_value).new(
           SimpleAMS::Options.new(
-            relation_value_for(relation.name), relation_options_for(relation)
+            relation_value, relation_options_for(relation, relation_value)
+          ),
+          SimpleAMS::Options.new(
+            resource, {
+              injected_options: {
+                serializer: relation.embedded
+              },
+              allowed_options: relation.embedded.options
+            }
           )
         )
       end
@@ -57,12 +73,12 @@ module SimpleAMS
       # *user injected when instantiating the SimpleAMS class
       # *relation options injected from parent serializer
       # *serializer class options
-      def relation_options_for(relation)
+      def relation_options_for(relation, relation_value)
         _relation_options = {
           injected_options: (relation.options || {}).merge(
             options.relation_options_for(
               relation.name
-            ).merge(
+            ).select{|k, v| !v.nil?}.merge(
               expose: options.expose
             )
           ).merge(
@@ -71,19 +87,33 @@ module SimpleAMS
             }
           )
         }
+
+        if relation.collection? || relation_value.respond_to?(:each)
         #TODO: deep merge, can we automate this somehow ?
-        _relation_options[:injected_options][:collection] = (_relation_options[:collection] || {}).merge(
-          name: relation.name
-        )
+          _relation_options[:injected_options][:collection] = {
+            name: relation.name
+          }.merge(_relation_options[:injected_options][:collection] || {})
+        else
+          _relation_options[:injected_options][:name] = relation.name
+        end
 
         return _relation_options
       end
+=begin
+      def embedded_relation_options_for(relation)
+        _relation_options = relation_options_for(relation).merge(
+          allowed_options: relation.embedded.options
+        )
+        _relation_options[:injected_options][:serializer] = relation.embedded
 
-      def renderer_klass_for(relation)
-        renderer = SimpleAMS::Document
-        collection_renderer = renderer::Folder
+        return _relation_options
+      end
+=end
 
-        relation.collection? ? collection_renderer : renderer
+      def renderer_klass_for(relation, relation_value)
+        return SimpleAMS::Document::Folder if relation.collection?
+        return SimpleAMS::Document::Folder if relation_value.respond_to?(:each)
+        return SimpleAMS::Document
       end
 
 =begin TODO: Add that as public method, should help performance in edge cases