simple_ams 0.2.1 → 0.2.6

data/lib/simple_ams/document.rb

@@ -1,4 +1,4 @@
-require "simple_ams"
+require 'simple_ams'
 
 class SimpleAMS::Document
   attr_reader :options, :embedded_options, :serializer, :resource
@@ -17,12 +17,14 @@ class SimpleAMS::Document
   def fields
     return @fields if defined?(@fields)
     return @fields = [] if options.fields.empty?
-    return @fields ||= self.class::Fields.new(options)
+
+    @fields ||= self.class::Fields.new(options)
   end
 
   def relations
     return @relations if defined?(@relations)
-    return @relations ||= self.class::Relations.new(
+
+    @relations ||= self.class::Relations.new(
       options, options.relations
     )
   end
@@ -42,30 +44,36 @@ class SimpleAMS::Document
   def links
     return @links if defined?(@links)
     return @links = {} if options.links.empty?
-    return @links ||= self.class::Links.new(options)
+
+    @links ||= self.class::Links.new(options)
   end
 
   def metas
     return @metas if defined?(@metas)
     return @metas = {} if options.metas.empty?
-    return @metas ||= self.class::Metas.new(options)
+
+    @metas ||= self.class::Metas.new(options)
   end
 
   def forms
     return @forms if defined?(@forms)
     return @forms = {} if options.forms.empty?
-    return @forms ||= self.class::Forms.new(options)
+
+    @forms ||= self.class::Forms.new(options)
   end
 
   def generics
     return @generics if defined?(@generics)
     return @generics = {} if options.generics.empty?
-    return @generics ||= self.class::Generics.new(options)
+
+    @generics ||= self.class::Generics.new(options)
   end
 
+  # rubocop:disable Naming/MemoizedInstanceVariableName
   def folder?
-    @is_folder ||= self.is_a?(self.class::Folder)
+    @is_folder ||= is_a?(self.class::Folder)
   end
+  # rubocop:enable Naming/MemoizedInstanceVariableName
 
   def document?
     !folder?
@@ -91,7 +99,7 @@ class SimpleAMS::Document
       @resource = options.resource
     end
 
-    def each(&block)
+    def each
       return enum_for(:each) unless block_given?
 
       members.each do |resource|
@@ -101,7 +109,7 @@ class SimpleAMS::Document
       self
     end
 
-    #do we really need this method ?
+    # do we really need this method ?
     def documents
       each.map
     end
@@ -111,35 +119,28 @@ class SimpleAMS::Document
     end
 
     private
-      attr_reader :_options
-
-      def options_for(resource)
-        if resource_options.serializer_class.respond_to?(:call)
-          SimpleAMS::Options.new(resource, {
-            injected_options: resource_options.injected_options.merge({
-              serializer: serializer_for(resource)
-            }),
-            allowed_options: serializer_for(resource).options
-          })
-        else
-          resource_options.with_resource(resource)
-=begin
-          # we need to optimize that using tracked properties
-          SimpleAMS::Options.new(resource, {
-            injected_options: resource_options.injected_options.merge({
-              serializer: serializer_for(resource)
-            }),
-            allowed_options: serializer_for(resource).options
-          })
-=end
-        end
+
+    attr_reader :_options
+
+    def options_for(resource)
+      if resource_options.serializer_class.respond_to?(:call)
+        SimpleAMS::Options.new(
+          resource,
+          injected_options: resource_options.injected_options.merge({
+            serializer: serializer_for(resource)
+          }),
+          allowed_options: serializer_for(resource).options
+        )
+      else
+        resource_options.with_resource(resource)
       end
+    end
 
-      def serializer_for(resource)
-        _serializer = resource_options.serializer_class
-        _serializer = _serializer.call(resource) if _serializer.respond_to?(:call)
+    def serializer_for(resource)
+      serializer = resource_options.serializer_class
+      serializer = serializer.call(resource) if serializer.respond_to?(:call)
 
-        return _serializer
-      end
+      serializer
+    end
   end
 end

data/lib/simple_ams/document/fields.rb

@@ -1,51 +1,50 @@
-require "simple_ams"
+require 'simple_ams'
 
-module SimpleAMS
-  class Document::Fields
-    include Enumerable
+class SimpleAMS::Document::Fields
+  include Enumerable
 
-    Field = Struct.new(:key, :value)
+  Field = Struct.new(:key, :value)
 
-    def initialize(options)
-      @options = options
-      @members = options.fields #[:field1, :field2]
-    end
-
-    def [](key)
-      found = members.find{|field| field == key}
-      return nil unless found
+  def initialize(options)
+    @options = options
+    @members = options.fields # [:field1, :field2]
+  end
 
-      value_of(found)
-    end
+  def [](key)
+    found = members.find { |field| field == key }
+    return nil unless found
 
-    #TODO: Can we make this faster?
-    def each(&block)
-      return enum_for(:each) unless block_given?
+    value_of(found)
+  end
 
-      members.each{ |key|
-        yield value_of(key)
-      }
+  # TODO: Can we make this faster?
+  def each
+    return enum_for(:each) unless block_given?
 
-      self
+    members.each do |key|
+      yield value_of(key)
     end
 
-    def any?
-      members.any?
-    end
+    self
+  end
 
-    def empty?
-      members.empty?
-    end
+  def any?
+    members.any?
+  end
+
+  def empty?
+    members.empty?
+  end
+
+  private
 
-    private
-      attr_reader :members, :options
+  attr_reader :members, :options
 
-      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
-      end
+  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
   end
 end

data/lib/simple_ams/document/forms.rb

@@ -1,13 +1,11 @@
-require "simple_ams"
+require 'simple_ams'
 
-module SimpleAMS
-  class Document::Forms < Document::Generics
-    def initialize(options)
-      @options = options
-      @members = options.forms
-    end
+class SimpleAMS::Document::Forms < SimpleAMS::Document::Generics
+  def initialize(options)
+    @options = options
+    @members = options.forms
+  end
 
-    class Form < Document::Generics::Generic
-    end
+  class Form < SimpleAMS::Document::Generics::Generic
   end
 end

data/lib/simple_ams/document/generics.rb

@@ -1,51 +1,49 @@
-require "simple_ams"
+require 'simple_ams'
 
-module SimpleAMS
-  class Document::Generics
-    include Enumerable
+class SimpleAMS::Document::Generics
+  include Enumerable
 
-    Generic = Struct.new(:name, :value, :options)
+  Generic = Struct.new(:name, :value, :options)
 
-    def initialize(options)
-      @options = options
-      @members = options.generics
-    end
-
-    def [](key)
-      found = members.find{|generic| generic.name == key}
-      return nil unless found
+  def initialize(options)
+    @options = options
+    @members = options.generics
+  end
 
-      return with_decorator(found)
-    end
+  def [](key)
+    found = members.find { |generic| generic.name == key }
+    return nil unless found
 
-    def each(&block)
-      return enum_for(:each) unless block_given?
+    with_decorator(found)
+  end
 
-      members.each{ |member|
-        yield with_decorator(member)
-      }
+  def each
+    return enum_for(:each) unless block_given?
 
-      self
+    members.each do |member|
+      yield with_decorator(member)
     end
 
-    def any?
-      members.any?
-    end
+    self
+  end
 
-    def empty?
-      members.empty?
-    end
+  def any?
+    members.any?
+  end
+
+  def empty?
+    members.empty?
+  end
+
+  private
 
-    private
-      attr_reader :members, :options
+  attr_reader :members, :options
 
-      def with_decorator(generic)
-        Generic.new(
-          generic.name,
-          generic.respond_to?(:call) ? generic.value.call : generic.value,
-          generic.options
-        )
-      end
+  def with_decorator(generic)
+    Generic.new(
+      generic.name,
+      generic.respond_to?(:call) ? generic.value.call : generic.value,
+      generic.options
+    )
   end
 end
-

data/lib/simple_ams/document/links.rb

@@ -1,13 +1,11 @@
-require "simple_ams"
+require 'simple_ams'
 
-module SimpleAMS
-  class Document::Links < Document::Generics
-    def initialize(options)
-      @options = options
-      @members = options.links
-    end
+class SimpleAMS::Document::Links < SimpleAMS::Document::Generics
+  def initialize(options)
+    @options = options
+    @members = options.links
+  end
 
-    class Generic < Document::Generics::Generic
-    end
+  class Generic < SimpleAMS::Document::Generics::Generic
   end
 end

data/lib/simple_ams/document/metas.rb

@@ -1,15 +1,11 @@
-require "simple_ams"
+require 'simple_ams'
 
-module SimpleAMS
-  class Document::Metas < Document::Generics
-    def initialize(options)
-      @options = options
-      @members = options.metas
-    end
+class SimpleAMS::Document::Metas < SimpleAMS::Document::Generics
+  def initialize(options)
+    @options = options
+    @members = options.metas
+  end
 
-    class Meta < Document::Generics::Generic
-    end
+  class Meta < SimpleAMS::Document::Generics::Generic
   end
 end
-
-

data/lib/simple_ams/document/primary_id.rb

@@ -1,23 +1,20 @@
-module SimpleAMS
-  class Document::PrimaryId
-    attr_reader :name
+class SimpleAMS::Document::PrimaryId
+  attr_reader :name
 
-    def initialize(options)
-      @options = options
-      @name = options.primary_id.name
-    end
+  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
+  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
+  def options
+    @options.primary_id.options
   end
 end
-

data/lib/simple_ams/document/relations.rb

@@ -1,125 +1,115 @@
-require "simple_ams"
-
-#TODO: Add memoization for the relations object (iteration + access)
-module SimpleAMS
-  class Document::Relations
-    include Enumerable
-
-    def initialize(options, relations)
-      @options = options
-      @relations = relations
-      @serializer = options.serializer
-      @resource = options.resource
-    end
+require 'simple_ams'
 
-    def [](key)
-      found = relations.find{|relation| relation.name == key}
-      return nil unless found
+# TODO: Add memoization for the relations object (iteration + access)
+class SimpleAMS::Document::Relations
+  include Enumerable
 
-      return relation_for(found)
-    end
+  def initialize(options, relations)
+    @options = options
+    @relations = relations
+    @serializer = options.serializer
+    @resource = options.resource
+  end
 
-    def each(&block)
-      return enum_for(:each) unless block_given?
+  def [](key)
+    found = relations.find { |relation| relation.name == key }
+    return nil unless found
 
-      relations.each{ |relation|
-        yield relation_for(relation)
-      }
+    relation_for(found)
+  end
 
-      self
-    end
+  def each
+    return enum_for(:each) unless block_given?
 
-    def empty?
-      relations.length == 0
+    relations.each do |relation|
+      yield relation_for(relation)
     end
 
-    def available
-      return @available ||= [] if relations.available.empty?
+    self
+  end
+
+  def empty?
+    relations.length.zero?
+  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)
+    relation_value = relation_value_for(relation.name)
+
+    renderer_klass_for(relation, relation_value).new(
+      SimpleAMS::Options.new(
+        relation_value, **relation_options_for(relation, relation_value)
+      ),
+      SimpleAMS::Options.new(
+        resource,
+        injected_options: {
+          serializer: relation.embedded
+        },
+        allowed_options: relation.embedded.options
+      )
+    )
+  end
 
-      @available ||= self.class.new(options, relations.available)
+  # TODO: rename that to relation and existing relation to relationship
+  def relation_value_for(name)
+    if serializer.respond_to?(name)
+      serializer.send(name)
+    else
+      resource.send(name)
     end
+  end
 
-    private
-      attr_reader :options, :relations, :serializer, :resource
-
-      def relation_for(relation)
-        relation_value = relation_value_for(relation.name)
-
-        renderer_klass_for(relation, relation_value).new(
-          SimpleAMS::Options.new(
-            relation_value, relation_options_for(relation, relation_value)
-          ),
-          SimpleAMS::Options.new(
-            resource, {
-              injected_options: {
-                serializer: relation.embedded
-              },
-              allowed_options: relation.embedded.options
-            }
-          )
+  # 3 options are merged:
+  # *user injected when instantiating the SimpleAMS class
+  # *relation options injected from parent serializer
+  # *serializer class options
+  # rubocop:disable Lint/UnderscorePrefixedVariableName
+  def relation_options_for(relation, relation_value)
+    _relation_options = {
+      injected_options: (relation.options || {}).merge(
+        options.relation_options_for(
+          relation.name
+        ).reject { |_k, v| v.nil? }.merge(
+          expose: options.expose
         )
-      end
-
-      #TODO: rename that to relation and existing relation to relationship
-      def relation_value_for(name)
-        if serializer.respond_to?(name)
-          serializer.send(name)
-        else
-          resource.send(name)
-        end
-      end
-
-      #4 options are merged:
-      # *user injected when instantiating the SimpleAMS class
-      # *relation options injected from parent serializer
-      # *serializer class options
-      def relation_options_for(relation, relation_value)
-        _relation_options = {
-          injected_options: (relation.options || {}).merge(
-            options.relation_options_for(
-              relation.name
-            ).select{|k, v| !v.nil?}.merge(
-              expose: options.expose
-            )
-          ).merge(
-            _internal: {
-              module: serializer.class.to_s.rpartition('::')[0]
-            }
-          )
+      ).merge(
+        _internal: {
+          module: serializer.class.to_s.rpartition('::')[0]
         }
+      )
+    }
+
+    if relation.collection? || relation_value.respond_to?(:each)
+      # TODO: deep merge, can we automate this somehow ?
+      _relation_options[:injected_options][:collection] = {
+        name: relation.name
+      }.merge(_relation_options[:injected_options][:collection] || {})
+    else
+      _relation_options[:injected_options][:name] = relation.name
+    end
 
-        if relation.collection? || relation_value.respond_to?(:each)
-        #TODO: deep merge, can we automate this somehow ?
-          _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
-
-        return _relation_options
-      end
-=end
-
-      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
-      def relationship_info_for(name)
-        relations.find{|i| i.name == name}
-      end
-=end
+    _relation_options
   end
+  # rubocop:enable Lint/UnderscorePrefixedVariableName
+
+  def renderer_klass_for(relation, relation_value)
+    return SimpleAMS::Document::Folder if relation.collection?
+    return SimpleAMS::Document::Folder if relation_value.respond_to?(:each)
+
+    SimpleAMS::Document
+  end
+
+  # TODO: Add that as public method, should help performance in edge cases
+  #       def relationship_info_for(name)
+  #         relations.find{|i| i.name == name}
+  #       end
 end