simple_ams 0.1.0

data/lib/simple_ams/document.rb

@@ -0,0 +1,93 @@
+require "simple_ams"
+
+class SimpleAMS::Document
+  attr_reader :options, :serializer, :resource
+
+  def initialize(options = SimpleAMS::Options.new)
+    @options = options
+    @serializer = options.serializer
+    @resource = options.resource
+  end
+
+  def primary_id
+    options.primary_id
+  end
+
+  def fields
+    return @fields ||= self.class::Fields.new(options)
+  end
+
+  def relations
+    return @relations ||= self.class::Relations.new(options)
+  end
+
+  def name
+    options.name
+  end
+
+  def type
+    options.type
+  end
+
+  def adapter
+    options.adapter
+  end
+
+  def links
+    return @links ||= self.class::Links.new(options)
+  end
+
+  def metas
+    return @metas ||= self.class::Metas.new(options)
+  end
+
+  def folder?
+    self.is_a?(self.class::Folder)
+  end
+
+  def document?
+    !folder?
+  end
+
+  class Folder < self
+    attr_reader :collection
+
+    def initialize(options)
+      @_options = options
+      @options = @_options.collection_options
+
+      @collection = options.collection
+    end
+
+    def documents
+      @documents = collection.map do |resource|
+        SimpleAMS::Document.new(options_for(resource))
+      end
+    end
+
+    def resource_options
+      _options
+    end
+
+    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
+        })
+      end
+
+      def serializer_for(resource)
+        _serializer = resource_options.serializer_class
+        _serializer = _serializer.call(resource) if _serializer.respond_to?(:call)
+
+        return _serializer
+      end
+  end
+end

data/lib/simple_ams/dsl.rb

@@ -0,0 +1,216 @@
+require "simple_ams"
+
+module SimpleAMS::DSL
+  def self.included(host_class)
+    host_class.extend ClassMethods
+
+    _klass = Class.new(Object).extend(ClassMethods)
+    _klass.instance_eval do
+      def options
+        {
+          adapter: adapter,
+          primary_id: primary_id,
+          type: type,
+          fields: fields,
+          relations: relations,
+          includes: includes,
+          links: links,
+          metas: metas,
+        }
+      end
+    end
+
+    host_class.const_set('Collection', _klass)
+  end
+
+  module ClassMethods
+    #TODO: Shouldn't we call here super to presever user's behavior ?
+    def inherited(subclass)
+      _klass = Class.new(Object).extend(ClassMethods)
+      _klass.instance_eval do
+        def options
+          {
+            adapter: adapter,
+            primary_id: primary_id,
+            type: type,
+            fields: fields,
+            relations: relations,
+            includes: includes,
+            links: links,
+            metas: metas,
+          }
+        end
+      end
+
+      subclass.const_set('Collection', _klass)
+    end
+
+    def default_options
+      @_default_options ||= {
+        adapter: [SimpleAMS::Adapters::AMS, {}],
+        primary_id: [:id, {}],
+        type: [_default_type_name, {}]
+      }
+    end
+
+    #TODO: Add tests !!
+    def _default_type_name
+      if self.to_s.end_with?('::Collection')
+        _name = self.to_s.gsub(
+          'Serializer',''
+        ).gsub(
+          '::Collection', ''
+        ).downcase.split('::').last
+
+        return "#{_name}_collection".to_sym
+      else
+        return self.to_s.gsub('Serializer','').downcase.split('::').last.to_sym
+      end
+    end
+    def with_options(options = {})
+      @_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)
+        elsif meths.include?(key)
+          self.send(key, value) if value.is_a?(Array)
+          self.send(key, value)
+        else
+          #TODO: Add a proper logger
+          puts "SimpeAMS: #{key} is not recognized, ignoring (from #{self.to_s})"
+        end
+      end
+
+      return @_options
+    end
+
+    #same for other ValueHashes
+    def adapter(name = nil, options = {})
+      @_adapter ||= default_options[:adapter]
+      return @_adapter if name.nil?
+
+      @_adapter = [name, options]
+    end
+
+    def primary_id(value = nil, options = {})
+      @_primary_id ||= default_options[:primary_id]
+      return @_primary_id if value.nil?
+
+      @_primary_id = [value, options]
+    end
+
+    def type(value = nil, options = {})
+      @_type ||= default_options[:type]
+      return @_type if value.nil?
+
+      @_type = [value, options]
+    end
+
+    def attributes(*args)
+      @_attributes ||= []
+      return @_attributes.uniq if (args&.empty? || args.nil?)
+
+      append_attributes(args)
+    end
+    alias attribute attributes
+    alias fields attributes
+
+    def has_many(name, options = {})
+      append_relationship([__method__, name, options])
+    end
+
+    def has_one(name, options = {})
+      append_relationship([__method__, name, options])
+    end
+
+    def belongs_to(name, options = {})
+      append_relationship([__method__, name, options])
+    end
+
+    def relations
+      @_relations || []
+    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(_ = [])
+      relations.map{|rel| rel[1] }
+    end
+
+    def link(name, value, options = {})
+      append_link([name, value, options])
+    end
+
+    def meta(name = nil, value = nil, options = {})
+      append_meta([name, value, options])
+    end
+
+    def links(links = [])
+      links.map{|key, value| append_link([key, value].flatten(1))} if links.is_a?(Hash)
+
+      @_links ||= links
+    end
+
+    def metas(metas = [])
+      metas.map{|key, value| append_meta([key, value].flatten(1))} if metas.is_a?(Hash)
+
+      @_metas || []
+    end
+
+    def collection(name = nil, &block)
+      if block
+        self::Collection.class_eval do
+          instance_exec(&block)
+        end
+      end
+
+      self::Collection.type(name) if name
+
+      return self::Collection
+    end
+
+    def options
+      {
+        adapter: adapter,
+        primary_id: primary_id,
+        type: type,
+        fields: fields,
+        relations: relations,
+        includes: includes,
+        links: links,
+        metas: metas,
+        collection: collection
+      }
+    end
+
+    private
+      def append_relationship(rel)
+        @_relations ||= []
+
+        @_relations << rel
+      end
+
+      def append_attributes(*attrs)
+        @_attributes ||= []
+
+        @_attributes = (@_attributes << attrs).flatten.compact.uniq
+      end
+
+      def append_link(link)
+        @_links ||= []
+
+        @_links << link
+      end
+
+      def append_meta(meta)
+        @_metas ||= []
+
+        @_metas << meta
+      end
+
+      def empty_options
+      end
+  end
+end

data/lib/simple_ams/methy.rb

@@ -0,0 +1,10 @@
+module SimpleAMS::Methy
+  def self.of(hash = {})
+    m = Module.new
+    hash.each do |key, value|
+      m.send(:define_method, key){ value }
+    end
+
+    return m
+  end
+end

data/lib/simple_ams/options/adapter.rb

@@ -0,0 +1,9 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Adapter
+    include SimpleAMS::Options::Concerns::ValueHash
+
+    alias_method :klass, :value
+  end
+end

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

@@ -0,0 +1,45 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  module Concerns
+    #works for arrays that can hold either elements or object that respond_to? :name
+    module Filterable
+      #for optimizing performance, ask only the first element
+      #other idea is to create another module just for (Name)ValueHash objects
+      def &(other_filterables)
+        other_is_object = other_filterables.first.respond_to?(:name)
+
+        return self.class.new(
+          self.select{|m|
+            if other_is_object
+              other_filterables.include?(m.name)
+            else
+              other_filterables.include?(m)
+            end
+          }
+        )
+      end
+
+      #for optimizing performance, ask only the first element of self and save it as state
+      def include?(member)
+        unless defined?(@self_is_object)
+          @self_is_object = self.first.respond_to?(:name)
+        end
+
+        if @self_is_object
+          self.map(&:name).include?(member)
+        else
+          super
+        end
+      end
+
+      def raw
+        if self.first.respond_to?(:raw)
+          self.map(&:raw)
+        else
+          self.map{|i| i}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  module Concerns
+    module NameValueHash
+      attr_reader :name, :value, :options
+
+      def initialize(name, value, options = {}, resource:)
+        @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?(Array) && _value.length > 1
+            @options = (_value.last || {}).merge(options || {})
+          else
+            @options = options || {}
+          end
+        else
+          @value = value
+          @options = options || {}
+        end
+      end
+
+      def raw
+        [name, value, options]
+      end
+
+      private
+        attr_writer :name, :value, :options
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  module Concerns
+    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
+      end
+
+      alias_method :name, :value
+
+      def raw
+        [value, options]
+      end
+
+      private
+        attr_writer :value, :options
+    end
+  end
+end

data/lib/simple_ams/options/fields.rb

@@ -0,0 +1,7 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Fields < Array
+    include SimpleAMS::Options::Concerns::Filterable
+  end
+end

data/lib/simple_ams/options/includes.rb

@@ -0,0 +1,7 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Includes < Array
+    include SimpleAMS::Options::Concerns::Filterable
+  end
+end

data/lib/simple_ams/options/links.rb

@@ -0,0 +1,11 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Links < Array
+    include SimpleAMS::Options::Concerns::Filterable
+
+    class Link
+      include SimpleAMS::Options::Concerns::NameValueHash
+    end
+  end
+end

data/lib/simple_ams/options/metas.rb

@@ -0,0 +1,12 @@
+require "simple_ams"
+
+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
+  end
+end

data/lib/simple_ams/options/primary_id.rb

@@ -0,0 +1,7 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class PrimaryId
+    include SimpleAMS::Options::Concerns::ValueHash
+  end
+end

data/lib/simple_ams/options/relation.rb

@@ -0,0 +1,31 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Relation
+    attr_reader :type, :name, :options
+    def initialize(type, name, options = {})
+      @type = type.to_sym
+      @name = name.is_a?(String) ? name.to_sym : name
+      @options = options
+
+      @many = type == :has_many ? true : false
+    end
+
+    alias relation name
+
+    def raw
+      [type, name, options]
+    end
+
+    def collection?
+      @many
+    end
+
+    def single?
+      !array
+    end
+
+    private
+      attr_writer :type, :name, :options
+  end
+end

data/lib/simple_ams/options/type.rb

@@ -0,0 +1,8 @@
+require "simple_ams"
+
+class SimpleAMS::Options
+  class Type
+    include SimpleAMS::Options::Concerns::ValueHash
+  end
+end
+