simple_ams 0.1.0

data/lib/simple_ams/options.rb

@@ -0,0 +1,299 @@
+require "simple_ams"
+
+module SimpleAMS
+  class Options
+    class Collection < self; end
+
+    attr_reader :resource, :allowed_options, :injected_options
+
+    #injected_options is always a Hash object
+    def initialize(resource, injected_options: {}, allowed_options: nil)
+      @resource = resource
+      @injected_options = injected_options || {}
+      @_internal = @injected_options[:_internal] || {}
+      @allowed_options = allowed_options || fetch_allowed_options
+    end
+    alias collection resource
+
+    def relation_options_for(relation_name)
+      return _relation_options[relation_name] || {}
+    end
+
+    def primary_id
+      return @primary_id if defined?(@primary_id)
+
+      _options = injected_options.fetch(:primary_id, nil)
+      _options = allowed_options.fetch(:primary_id, nil) unless _options
+
+      return @primary_id ||= PrimaryId.new(*_options)
+    end
+
+    def type
+      return @type if defined?(@type)
+
+      _options = injected_options.fetch(:type, nil)
+      _options = allowed_options.fetch(:type, nil) unless _options
+
+      return @type ||= Type.new(*_options)
+    end
+
+    #that's handful
+    def name
+      @name ||= injected_options[:name] || allowed_options[:name] || type.name
+    end
+
+    #TODO: optimize for nested fields?
+    def fields
+      return @fields if defined?(@fields)
+
+      injected = injected_options.fetch(:fields, nil)
+
+      if injected.nil?
+        return @fields = Fields.new(allowed_options.fetch(:fields).uniq)
+      else
+        return @fields = Fields.new(options_for(
+          injected: Fields.new(injected_options.fetch(:fields, nil)),
+          allowed: Fields.new(allowed_options.fetch(:fields).uniq)
+        ).uniq)
+      end
+    end
+
+    def includes
+      return @includes if defined?(@includes)
+
+      injected = injected_options.fetch(:includes, nil)
+
+      if injected.nil?
+        return @includes = Includes.new(allowed_options.fetch(:includes).uniq)
+      else
+        return @includes = Includes.new(options_for(
+          injected: Includes.new(injected_options.fetch(:includes, nil)),
+          allowed: Includes.new(allowed_options.fetch(:includes).uniq)
+        ).uniq)
+      end
+    end
+
+    #TODO: correctly loop over injected relations, although should be a rarely used feature
+    def relations
+      return @relations if defined?(@relations) #||= options_for(
+
+      relations = injected_options.fetch(:relations, nil)
+      relations = allowed_options.fetch(:relations, []) if relations.nil?
+
+      return @relations = relations.map{|rel| Relation.new(*rel)}.select{
+          |relation| includes.include?(relation.name)
+        }
+    end
+
+    #TODO: add method-based links, should boost performance
+    def links
+      return @links if defined?(@links)
+
+      injected = injected_options.fetch(:links, nil)
+      if injected
+        injected = Links.new(
+          injected.map{|l| Links::Link.new(*l.flatten, resource: resource)}
+        )
+      end
+
+      allowed = Links.new(
+        allowed_options.fetch(:links).map{|l| Links::Link.new(*l, resource: resource)}
+      )
+
+      return @links = Links.new(options_for(
+        #TODO: correctly loop over injected properties
+        injected: injected,
+        allowed: allowed,
+      ).uniq{|link| link.name})
+    end
+
+    #TODO: add method-based metas, should boost performance
+    def metas
+      return @metas if defined?(@metas)
+
+      injected = injected_options.fetch(:metas, nil)
+      if injected
+        injected = Metas.new(
+          injected.map{|l| Metas::Meta.new(*l.flatten, resource: resource)}
+        )
+      end
+      allowed = Metas.new(
+        allowed_options.fetch(:metas).map{|l| Metas::Meta.new(*l, resource: resource)}
+      )
+
+      return @metas = Metas.new(options_for(
+        #TODO: correctly loop over injected properties
+        injected: injected,
+        allowed: allowed,
+      ).uniq{|meta| meta.name})
+    end
+
+    #TODO: handle case of proc
+    def serializer
+      return @serializer if defined?(@serializer)
+
+      _serializer = injected_options.fetch(:serializer, serializer_class)
+
+      return @serializer = _serializer.new.extend(
+        SimpleAMS::Methy.of(
+          expose.merge({
+            object: resource
+          })
+        )
+      )
+    end
+
+    def adapter
+      return @adapter if defined?(@adapter)
+
+      @adapter = Adapter.new(*injected_options.fetch(:adapter, [nil]))
+      @adapter = Adapter.new(*allowed_options.fetch(:adapter, [nil])) if @adapter.value.nil?
+      @adapter = Adapter.new(SimpleAMS::Adapters::AMS) if @adapter.value.nil?
+
+      return @adapter
+    end
+
+    # the following should be the same for all (nested) serializers of the same document
+    def expose
+      @expose ||= injected_options.fetch(:expose, {})
+    end
+
+    def as_hash
+      {
+        adapter: adapter.raw,
+        primary_id: primary_id.raw,
+        type: type.raw,
+        name: name,
+        fields: fields.raw,
+        serializer: serializer_class,
+        #relations: relations.raw, #TODO: why have I commented that out ?
+        includes: includes.raw,
+        links: links.raw,
+        metas: metas.raw,
+        expose: expose,
+        _internal: _internal
+      }
+    end
+
+    def collection_options
+      return @collection_options if defined?(@collection_options)
+
+      #TODO: Do we need that merge ?
+      _injected_options = @injected_options.fetch(:collection, {}).merge({
+        serializer: collection_serializer_class
+      })
+      _allowed_options = @allowed_options.fetch(:collection).options
+
+      return @collection_options = self.class::Collection.new(
+        resource,
+        injected_options: _injected_options,
+        allowed_options: _allowed_options
+      )
+    end
+
+    def serializer_class
+      return @serializer_class if defined?(@serializer_class)
+
+      @serializer_class = injected_options.fetch(:serializer, nil)
+
+      return @serializer_class if @serializer_class 
+
+      return @serializer_class = infer_serializer
+    end
+
+    #TODO: maybe have that inside :collection? (isomorphism)
+    def collection_serializer_class
+      return @collection_serializer_class if defined?(@collection_serializer_class)
+
+      if serializer_class.is_a?(Proc)
+        @collection_serializer_class = injected_options[:collection_serializer]
+        if @collection_serializer_class.nil?
+          raise "In case of a proc serializer, you need to specify a collection_serializer"
+        end
+      else
+        @collection_serializer_class = serializer_class
+      end
+
+      return @collection_serializer_class
+    end
+
+    private
+      attr_reader :_internal
+=begin
+      def is_collection?
+        _internal[:is_collection] == true
+      end
+=end
+
+      def options_for(allowed:, injected:)
+        if not injected.nil?
+          allowed = injected.class.new(
+            injected.map{|s| s.is_a?(Hash) ? s.keys.first : s}
+          ) & allowed
+        end
+
+        return allowed
+      end
+
+      def _relation_options
+        return @_relation_options if defined?(@_relation_options)
+
+        @_relation_options = relations.inject({}){|memo, relation|
+          includes_value = (injected_options[:includes] || {}).select{|incl|
+            incl.is_a?(Hash)
+          }.find{|incl_hash|
+            incl_hash.keys.first.to_s == relation.name.to_s
+          }
+          if includes_value
+            includes_value = includes_value[relation.name]
+          else
+            #it's important here to return empty array if nothing is found..
+            includes_value = []
+          end
+
+          fields_value = (injected_options[:fields] || {}).select{|field|
+            field.is_a?(Hash)
+          }.find{|field_hash|
+            field_hash.keys.first.to_s == relation.name.to_s
+          } 
+
+          #.. while here just nil will work (pick default fields from serializer)
+          fields_value = fields_value[relation.name] if fields_value
+
+          memo[relation.name] = {
+            includes: includes_value,
+            fields: fields_value
+          }
+          memo
+        }
+      end
+
+      #TODO: raise exception if both are nil!
+      def fetch_allowed_options
+        _serializer_class = self.serializer_class
+        if _serializer_class.is_a?(Proc)
+          _serializer_class = self.collection_serializer_class
+        end
+
+        _allowed_options = _serializer_class&.options
+
+        return _allowed_options
+      end
+
+      def infer_serializer
+        namespace = _internal[:module] ? "#{_internal[:module]}::" : ""
+        resource_klass = resource.kind_of?(Array) ? resource.first.class : resource.class
+        if resource_klass == NilClass
+          return EmptySerializer
+        else
+          return Object.const_get("#{namespace}#{resource_klass.to_s}Serializer")
+        end
+      rescue NameError => _
+        raise "Could not infer serializer for #{resource.class}, maybe specify it? (tried #{namespace}#{resource_klass.to_s}Serializer)"
+      end
+
+      class EmptySerializer
+        include SimpleAMS::DSL
+      end
+  end
+end

data/lib/simple_ams/renderer.rb

@@ -0,0 +1,59 @@
+require "simple_ams"
+
+module SimpleAMS
+  class Renderer
+    def initialize(resource, options = {})
+      @resource = resource
+      @options = SimpleAMS::Options.new(resource, injected_options: options)
+    end
+
+    #resource decorator ?
+    def document
+      @document ||= SimpleAMS::Document.new(options)
+    end
+
+    def name
+      @options.name
+    end
+
+    def as_json
+      options.adapter.klass.new(document, options.adapter.options).as_json
+    end
+
+    def to_json
+      as_json.to_json
+    end
+
+    class Collection
+      def initialize(collection, options = {})
+        @collection = collection
+        @options = SimpleAMS::Options.new(collection, {
+          injected_options: options.merge(_internal: is_collection)
+        })
+      end
+
+      def folder
+        @folder ||= SimpleAMS::Document::Folder.new(options)
+      end
+
+      def as_json
+        options.adapter.klass::Collection.new(folder, options.adapter.options).as_json
+      end
+
+      def to_json
+        as_json.to_json
+      end
+
+      private
+        attr_reader :collection, :options
+
+        def is_collection
+          { is_collection: true }
+        end
+    end
+
+    private
+      attr_reader :resource, :options
+  end
+
+end

data/lib/simple_ams/version.rb

@@ -0,0 +1,3 @@
+module SimpleAMS
+  VERSION = "0.1.0"
+end

data/lib/simple_ams.rb

@@ -0,0 +1,29 @@
+require "delegate"
+require "simple_ams/version"
+require "simple_ams/methy"
+require "simple_ams/document"
+require "simple_ams/dsl"
+require "simple_ams/adapters"
+require "simple_ams/adapters/ams"
+require "simple_ams/renderer"
+
+require "simple_ams/options"
+require "simple_ams/options/concerns/filterable"
+require "simple_ams/options/concerns/name_value_hash"
+require "simple_ams/options/concerns/value_hash"
+require "simple_ams/options/adapter"
+require "simple_ams/options/fields"
+require "simple_ams/options/includes"
+require "simple_ams/options/links"
+require "simple_ams/options/metas"
+require "simple_ams/options/primary_id"
+require "simple_ams/options/type"
+require "simple_ams/options/relation"
+
+require "simple_ams/document/fields"
+require "simple_ams/document/relations"
+require "simple_ams/document/links"
+require "simple_ams/document/metas"
+
+module SimpleAMS
+end

data/simple_ams.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "simple_ams/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "simple_ams"
+  spec.version       = SimpleAMS::VERSION
+  spec.authors       = ["Filippos Vasilakis"]
+  spec.email         = ["vasilakisfil@gmail.com"]
+
+  spec.summary       = %q{ActiveModel Serializers, simplified.}
+  spec.description   = %q{ActiveModel Serializers, simplified.}
+  spec.homepage      = "https://github.com/vasilakisfil/simple-ams"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "faker", "~> 1.8.5"
+  spec.add_development_dependency "pry", "~> 0.11.3"
+  spec.add_development_dependency "simplecov"
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: simple_ams
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Filippos Vasilakis
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.5
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: ActiveModel Serializers, simplified.
+email:
+- vasilakisfil@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/simple_ams.rb
+- lib/simple_ams/adapters.rb
+- lib/simple_ams/adapters/ams.rb
+- lib/simple_ams/document.rb
+- lib/simple_ams/document/fields.rb
+- lib/simple_ams/document/links.rb
+- lib/simple_ams/document/metas.rb
+- lib/simple_ams/document/relations.rb
+- lib/simple_ams/dsl.rb
+- lib/simple_ams/methy.rb
+- lib/simple_ams/options.rb
+- lib/simple_ams/options/adapter.rb
+- lib/simple_ams/options/concerns/filterable.rb
+- lib/simple_ams/options/concerns/name_value_hash.rb
+- lib/simple_ams/options/concerns/value_hash.rb
+- lib/simple_ams/options/fields.rb
+- lib/simple_ams/options/includes.rb
+- lib/simple_ams/options/links.rb
+- lib/simple_ams/options/metas.rb
+- lib/simple_ams/options/primary_id.rb
+- lib/simple_ams/options/relation.rb
+- lib/simple_ams/options/type.rb
+- lib/simple_ams/renderer.rb
+- lib/simple_ams/version.rb
+- simple_ams.gemspec
+homepage: https://github.com/vasilakisfil/simple-ams
+licenses: []
+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.12
+signing_key: 
+specification_version: 4
+summary: ActiveModel Serializers, simplified.
+test_files: []