simple_ams 0.1.0 → 0.1.1

data/lib/simple_ams/document.rb

@@ -1,24 +1,30 @@
 require "simple_ams"
 
 class SimpleAMS::Document
-  attr_reader :options, :serializer, :resource
+  attr_reader :options, :embedded_options, :serializer, :resource
 
-  def initialize(options = SimpleAMS::Options.new)
+  def initialize(options, embedded_options = nil)
     @options = options
+    @embedded_options = embedded_options
     @serializer = options.serializer
     @resource = options.resource
   end
 
   def primary_id
-    options.primary_id
+    @primary_id ||= self.class::PrimaryId.new(options)
   end
 
   def fields
+    return @fields if defined?(@fields)
+    return @fields = [] if options.fields.empty?
     return @fields ||= self.class::Fields.new(options)
   end
 
   def relations
-    return @relations ||= self.class::Relations.new(options)
+    return @relations if defined?(@relations)
+    return @relations ||= self.class::Relations.new(
+      options, options.relations
+    )
   end
 
   def name
@@ -34,13 +40,29 @@ class SimpleAMS::Document
   end
 
   def links
+    return @links if defined?(@links)
+    return @links = {} if options.links.empty?
     return @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)
   end
 
+  def forms
+    return @forms if defined?(@forms)
+    return @forms = {} if options.forms.empty?
+    return @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)
+  end
+
   def folder?
     self.is_a?(self.class::Folder)
   end
@@ -49,18 +71,37 @@ class SimpleAMS::Document
     !folder?
   end
 
+  def embedded
+    return nil unless embedded_options
+
+    @embedded ||= SimpleAMS::Document.new(embedded_options)
+  end
+
   class Folder < self
-    attr_reader :collection
+    include Enumerable
+    attr_reader :members
 
-    def initialize(options)
+    def initialize(options, embedded_options = nil)
       @_options = options
+      @embedded_options = embedded_options
       @options = @_options.collection_options
 
-      @collection = options.collection
+      @members = options.collection
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      members.each do |resource|
+        yield SimpleAMS::Document.new(options_for(resource))
+      end
+
+      self
     end
 
+    #do we really need this method ?
     def documents
-      @documents = collection.map do |resource|
+      @members.map do |resource|
         SimpleAMS::Document.new(options_for(resource))
       end
     end
@@ -72,15 +113,26 @@ class SimpleAMS::Document
     private
       attr_reader :_options
 
-      #TODO: OBS! here we have extra cost for nothing
-      #can't we just pass the resource_option with different resource?
       def options_for(resource)
-        SimpleAMS::Options.new(resource, {
-          injected_options: resource_options.injected_options.merge({
-            serializer: serializer_for(resource)
-          }),
-          allowed_options: resource_options.allowed_options
-        })
+        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
+=begin
+          SimpleAMS::Options.new(resource, {
+            injected_options: resource_options.injected_options.merge({
+              serializer: serializer_for(resource)
+            }),
+            allowed_options: serializer_for(resource).options
+          })
+        end
+=end
       end
 
       def serializer_for(resource)

data/lib/simple_ams/dsl.rb

@@ -16,16 +16,27 @@ module SimpleAMS::DSL
           includes: includes,
           links: links,
           metas: metas,
+          forms: forms,
+          generics: generics,
         }
       end
     end
 
-    host_class.const_set('Collection', _klass)
+    host_class.const_set('Collection_', _klass)
   end
 
   module ClassMethods
     #TODO: Shouldn't we call here super to presever user's behavior ?
     def inherited(subclass)
+      #TODO: why this breaks collection type?
+      subclass.with_options(
+        options.merge(
+          #TODO: maybe add another group of elements under dsl?
+          #this could be DSL::Type.new(type).explicit?
+          type.last[:_explicit] ? {} : {type: nil}
+        )
+      )
+
       _klass = Class.new(Object).extend(ClassMethods)
       _klass.instance_eval do
         def options
@@ -38,11 +49,20 @@ module SimpleAMS::DSL
             includes: includes,
             links: links,
             metas: metas,
+            forms: forms,
+            generics: generics,
           }
         end
       end
 
-      subclass.const_set('Collection', _klass)
+      _klass.with_options(
+        self::Collection_.options.merge(
+          #TODO: maybe add another group of elements under dsl?
+          #this could be DSL::Type.new(type).explicit?
+          type.last[:_explicit] ? {} : {type: nil}
+        )
+      )
+      subclass.const_set('Collection_', _klass)
     end
 
     def default_options
@@ -55,11 +75,11 @@ module SimpleAMS::DSL
 
     #TODO: Add tests !!
     def _default_type_name
-      if self.to_s.end_with?('::Collection')
+      if self.to_s.end_with?('::Collection_')
         _name = self.to_s.gsub(
           'Serializer',''
         ).gsub(
-          '::Collection', ''
+          '::Collection_', ''
         ).downcase.split('::').last
 
         return "#{_name}_collection".to_sym
@@ -71,11 +91,21 @@ module SimpleAMS::DSL
       @_options = options
       meths = SimpleAMS::DSL::ClassMethods.instance_methods(false)
       @_options.each do |key, value|
-        if key.to_sym == :collection
-          self.send(:collection){}.with_options(value)
+        if key == :relations
+          (value || []).each{|rel_value|
+            append_relationship(rel_value)
+          }
+        elsif key.to_sym == :collection
+          #TODO: Add proc option maybe?
+          if value.is_a?(Hash)
+            collection{}.with_options(value)
+          end
         elsif meths.include?(key)
-          self.send(key, value) if value.is_a?(Array)
-          self.send(key, value)
+          if (value.is_a?(Array) && value.first.is_a?(Array)) || value.is_a?(Hash)
+            self.send(key, value)
+          else
+            self.send(key, *value)
+          end
         else
           #TODO: Add a proper logger
           puts "SimpeAMS: #{key} is not recognized, ignoring (from #{self.to_s})"
@@ -85,26 +115,16 @@ module SimpleAMS::DSL
       return @_options
     end
 
-    #same for other ValueHashes
-    def adapter(name = nil, options = {})
-      @_adapter ||= default_options[:adapter]
-      return @_adapter if name.nil?
-
-      @_adapter = [name, options]
+    def adapter(value = nil, options = {})
+      @_adapter = _value_hash_for(@_adapter, value, options, :adapter)
     end
 
     def primary_id(value = nil, options = {})
-      @_primary_id ||= default_options[:primary_id]
-      return @_primary_id if value.nil?
-
-      @_primary_id = [value, options]
+      @_primary_id = _value_hash_for(@_primary_id, value, options, :primary_id)
     end
 
     def type(value = nil, options = {})
-      @_type ||= default_options[:type]
-      return @_type if value.nil?
-
-      @_type = [value, options]
+      @_type = _value_hash_for(@_type, value, options.merge(_explicit: true), :type)
     end
 
     def attributes(*args)
@@ -116,26 +136,50 @@ module SimpleAMS::DSL
     alias attribute attributes
     alias fields attributes
 
-    def has_many(name, options = {})
-      append_relationship([__method__, name, options])
+    def attributes=(*args)
+      @_attributes = []
+
+      attributes(args)
+    end
+
+    def has_many(name, options = {}, &block)
+      append_relationship(
+        [__method__, name, options, embedded_class_for(name, options, block)]
+      )
     end
 
-    def has_one(name, options = {})
-      append_relationship([__method__, name, options])
+    def has_one(name, options = {}, &block)
+      append_relationship(
+        [__method__, name, options, embedded_class_for(name, options, block)]
+      )
     end
 
-    def belongs_to(name, options = {})
-      append_relationship([__method__, name, options])
+    def belongs_to(name, options = {}, &block)
+      append_relationship(
+        [__method__, name, options, embedded_class_for(name, options, block)]
+      )
     end
 
     def relations
       @_relations || []
     end
 
+    def embedded_class_for(name, options, block)
+      embedded = Class.new(self)
+      klass_name = "Embedded#{name.to_s.capitalize}Options_"
+      self.const_set(klass_name, embedded)
+      embedded.with_options(
+        default_options.merge(options.select{|k| k != :serializer})
+      )
+      embedded.instance_exec(&block) if block
+
+      return embedded
+    end
+
     #TODO: there is no memoization here, hence we ignore includes manually set !!
     #Consider fixing it by employing an observer that will clean the instance var
     #each time @_relations is updated
-    def includes(_ = [])
+    def includes(*args)
       relations.map{|rel| rel[1] }
     end
 
@@ -147,28 +191,53 @@ module SimpleAMS::DSL
       append_meta([name, value, options])
     end
 
+    def form(name, value, options = {})
+      append_form([name, value, options])
+    end
+
+    def generic(name, value, options = {})
+      append_generic([name, value, options])
+    end
+
     def links(links = [])
+      return @_links ||= [] if links.empty?
       links.map{|key, value| append_link([key, value].flatten(1))} if links.is_a?(Hash)
 
       @_links ||= links
     end
 
     def metas(metas = [])
+      return @_metas ||= [] if metas.empty?
+
       metas.map{|key, value| append_meta([key, value].flatten(1))} if metas.is_a?(Hash)
 
-      @_metas || []
+      @_metas ||= metas
+    end
+
+    def forms(forms = [])
+      return @_forms ||= [] if forms.empty?
+      forms.map{|key, value| append_form([key, value].flatten(1))} if forms.is_a?(Hash)
+
+      @_forms ||= forms
+    end
+
+    def generics(generics = [])
+      return @_generics ||= [] if generics.empty?
+      generics.map{|key, value| append_generic([key, value].flatten(1))} if generics.is_a?(Hash)
+
+      @_generics ||= generics
     end
 
     def collection(name = nil, &block)
       if block
-        self::Collection.class_eval do
+        self::Collection_.class_eval do
           instance_exec(&block)
         end
       end
 
-      self::Collection.type(name) if name
+      self::Collection_.type(name) if name
 
-      return self::Collection
+      return self::Collection_
     end
 
     def options
@@ -181,11 +250,24 @@ module SimpleAMS::DSL
         includes: includes,
         links: links,
         metas: metas,
+        forms: forms,
+        generics: generics,
         collection: collection
       }
     end
 
+    def simple_ams?
+      true
+    end
+
     private
+      def _value_hash_for(current, value, options, name)
+        _type = current || default_options[name]
+        return _type if value.nil?
+
+        return [value, options]
+      end
+
       def append_relationship(rel)
         @_relations ||= []
 
@@ -210,6 +292,18 @@ module SimpleAMS::DSL
         @_metas << meta
       end
 
+      def append_form(form)
+        @_forms ||= []
+
+        @_forms << form
+      end
+
+      def append_generic(generic)
+        @_generics ||= []
+
+        @_generics << generic
+      end
+
       def empty_options
       end
   end

data/lib/simple_ams/options/concerns/name_value_hash.rb

@@ -5,14 +5,15 @@ class SimpleAMS::Options
     module NameValueHash
       attr_reader :name, :value, :options
 
-      def initialize(name, value, options = {}, resource:)
+      def initialize(name, value, options = {}, resource:, serializer:)
         @name = name.is_a?(String) ? name.to_sym : name
-        if value.is_a?(Proc)
-          _value = value.call(resource)
-          @value = _value.first
+        if value.is_a?(Proc) #TODO: maybe we should do duck typing instead?
+          _value = value.call(resource, serializer)
           if _value.is_a?(Array) && _value.length > 1
+            @value = _value.first
             @options = (_value.last || {}).merge(options || {})
           else
+            @value = _value
             @options = options || {}
           end
         else

data/lib/simple_ams/options/concerns/value_hash.rb

@@ -5,9 +5,20 @@ class SimpleAMS::Options
     module ValueHash
       attr_reader :value, :options
 
-      def initialize(value, options = {})
-        @value = value.is_a?(String) ? value.to_sym : value
-        @options = options.kind_of?(Hash) ? options || {} : options
+      def initialize(value, options = {}, resource:, serializer:)
+        if value.is_a?(Proc) #TODO: maybe we should do duck typing instead?
+          _value = value.call(resource, serializer)
+          if _value.is_a?(Array) && _value.length > 1
+            @value = _value.first
+            @options = (_value.last || {}).merge(options || {})
+          else
+            @value = _value
+            @options = options || {}
+          end
+        else
+          @value = value.is_a?(String) ? value.to_sym : value
+          @options = options || {}
+        end
       end
 
       alias_method :name, :value

data/lib/simple_ams/options/forms.rb

@@ -0,0 +1,12 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Forms < Array
+    include SimpleAMS::Options::Concerns::Filterable
+
+    class Form
+      include SimpleAMS::Options::Concerns::NameValueHash
+    end
+  end
+end
+

data/lib/simple_ams/options/generics.rb

@@ -0,0 +1,13 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Generics < Array
+    include SimpleAMS::Options::Concerns::Filterable
+
+    class Option
+      include SimpleAMS::Options::Concerns::NameValueHash
+    end
+  end
+end
+
+

data/lib/simple_ams/options/metas.rb

@@ -4,7 +4,6 @@ class SimpleAMS::Options
   class Metas < Array
     include SimpleAMS::Options::Concerns::Filterable
 
-    #TODO: should it check empty value ?
     class Meta
       include SimpleAMS::Options::Concerns::NameValueHash
     end

data/lib/simple_ams/options/relations.rb

@@ -0,0 +1,52 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Relations < Array
+    attr_reader :relations, :includes
+
+    def initialize(relations, includes = nil)
+      @relations = relations
+      @includes = includes
+
+      super(relations.map{|rel| Relations::Relation.new(*rel)})
+    end
+
+    def available
+      return @available ||= self if includes.nil?
+      return @available ||= [] if includes.empty?
+
+      @available ||= self.select{
+        |relation| includes.include?(relation.name)
+      }
+    end
+
+    class Relation
+      attr_reader :type, :name, :options, :embedded
+      def initialize(type, name, options = {}, embedded)
+        @type = type.to_sym
+        @name = name.is_a?(String) ? name.to_sym : name
+        @options = options
+        @embedded = embedded
+
+        @many = type == :has_many ? true : false
+      end
+
+      alias relation name
+
+      def raw
+        [type, name, options, embedded]
+      end
+
+      def collection?
+        @many
+      end
+
+      def single?
+        !collection?
+      end
+
+      private
+        attr_writer :type, :name, :options
+    end
+  end
+end