csverizer 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5409fdd6a87c19c96e4665e6b3cd1c59b1d5daf0aa00299d54af55120d1dfbbc
-  data.tar.gz: fd8be4d1bdf9049e4471c0e5c442e130ce05eeb2c82ec3e5c8c61740ea18908d
+  metadata.gz: 55eee804461744dce24ad41fccb06203f0eb9788849cedfd22ddbf3188398394
+  data.tar.gz: 2468a5c68cec4beca7fbe0d8c71f52dc81e2b129fb4c59b54653f37816fca595
 SHA512:
-  metadata.gz: 6db78ad668319a078b82044292f3167b61859c3164ab4a7f9dba0407013e0a84eb520371399d0b85c403b148a84cd940c3ca47f5ee7077d51d9e21872441390e
-  data.tar.gz: 803c802c2e6e2fc5fc3987b7d28db56c4eac56098844bde9afb436a373153c021cb4286d8dd26a976722f1c22c4b25239f55d05ad481366464cca51b0d3ef4ff
+  metadata.gz: 59abeb2c9a6a7eeb91d1d15bfddeb69914fc67c2eed7d6647ed4c76f4186b39f3d1834e60bdef3d21e626cdbb3b658ce1985a02afd0d3db4b76c847a1a71d094
+  data.tar.gz: d4e4531e84adc53d16fda163fc83743ad97d7f5de0f9f820862233b9f326671591832d2c32d84779bbc852e00868acbbadee873ad3a3544e654771a29754114a

data/lib/active_model/csv_array_serializer.rb

@@ -9,25 +9,19 @@ module ActiveModel
       @options = options
     end
 
-    def to_a
-      return ActiveModel::Csverizer.new(nil).to_a if @objects.nil?
-      @objects.collect do |object|
-        serializer = @each_serializer || ActiveModel::CsverizerFactory
-        serializer.new(object, @options).to_a
-      end
-    end
-
     def to_csv
+      serializer = @each_serializer || ActiveModel::CsverizerFactory
+      serializer = serializer.new(@objects.first, @options)
+      options_hash = @options.slice(:serializer)
+
       CSV.generate do |csv|
-        csv << attribute_names
-        to_a.each { |record| csv << record.first }
-      end
-    end
+        csv << serializer.attribute_names
+        serializer = @each_serializer || ActiveModel::CsverizerFactory
 
-    def attribute_names
-      return [] unless @objects
-      serializer = @each_serializer || ActiveModel::CsverizerFactory
-      serializer.new(@objects.first, @options).attribute_names
+        @objects.each do |record|
+          serializer.new(record, options_hash).to_a.each { |record| csv << record }
+        end
+      end
     end
   end
 end

data/lib/active_model/csverizer.rb

@@ -2,44 +2,316 @@ require 'csv'
 
 module ActiveModel
   class Csverizer
-    @_attributes = []
-    @associations = []
-    @root = true
+    @mutex = Mutex.new
 
     class << self
-      attr_accessor :_attributes, :associations, :root
+      def inherited(base)
+        base._root = _root
+        base._attributes = (_attributes || []).dup
+        base._associations = (_associations || {}).dup
+      end
+
+      def setup
+        @mutex.synchronize do
+          yield CONFIG
+        end
+      end
+
+      EMBED_IN_ROOT_OPTIONS = [
+        :include,
+        :embed_in_root,
+        :embed_in_root_key,
+        :embed_namespace
+      ].freeze
+
+      def embed(type, options={})
+        CONFIG.embed = type
+        if EMBED_IN_ROOT_OPTIONS.any? { |opt| options[opt].present? }
+          CONFIG.embed_in_root = true
+        end
+        if options[:embed_in_root_key].present?
+          CONFIG.embed_in_root_key = options[:embed_in_root_key]
+        end
+        ActiveSupport::Deprecation.warn <<-WARN
+** Notice: embed is deprecated. **
+The use of .embed method on a Serializer will be soon removed, as this should have a global scope and not a class scope.
+Please use the global .setup method instead:
+ActiveModel::Serializer.setup do |config|
+  config.embed = :#{type}
+  config.embed_in_root = #{CONFIG.embed_in_root || false}
+end
+        WARN
+      end
+
+      def format_keys(format)
+        @key_format = format
+      end
+      attr_reader :key_format
+
+      def serializer_for(resource, options = {})
+        if resource.respond_to?(:serializer_class)
+          resource.serializer_class
+        elsif resource.respond_to?(:to_ary)
+          if Object.constants.include?(:ArraySerializer)
+            ::ArraySerializer
+          else
+            ArraySerializer
+          end
+        else
+          klass_name = build_serializer_class(resource, options)
+          Serializer.serializers_cache.fetch_or_store(klass_name) do
+            _const_get(klass_name)
+          end
+        end
+      end
+
+      attr_accessor :_root, :_attributes, :_associations
+      alias root  _root=
+      alias root= _root=
+
+      def root_name
+        if name
+          root_name = name.demodulize.underscore.sub(/_serializer$/, '')
+          CONFIG.plural_default_root ? root_name.pluralize : root_name
+        end
+      end
+
+      def attributes(*attrs)
+        attrs.each do |attr|
+          striped_attr = strip_attribute attr
+
+          @_attributes << striped_attr
+
+          define_method striped_attr do
+            object.read_attribute_for_serialization attr
+          end unless method_defined?(attr)
+        end
+      end
+
+      def has_one(*attrs)
+        associate(Association::HasOne, *attrs)
+      end
+
+      def has_many(*attrs)
+        associate(Association::HasMany, *attrs)
+      end
+
+      def serializers_cache
+        @serializers_cache ||= Concurrent::Map.new
+      end
+
+      private
+
+      def strip_attribute(attr)
+        symbolized = attr.is_a?(Symbol)
+
+        attr = attr.to_s.gsub(/\?\Z/, '')
+        attr = attr.to_sym if symbolized
+        attr
+      end
+
+      def build_serializer_class(resource, options)
+        "".tap do |klass_name|
+          klass_name << "#{options[:namespace]}::" if options[:namespace]
+          klass_name << options[:prefix].to_s.classify if options[:prefix]
+          klass_name << "#{resource.class.name}Serializer"
+        end
+      end
+
+      def associate(klass, *attrs)
+        options = attrs.extract_options!
+
+        attrs.each do |attr|
+          define_method attr do
+            object.send attr
+          end unless method_defined?(attr)
+
+          @_associations[attr] = klass.new(attr, options)
+        end
+      end
     end
 
-    def self.inherited(base)
-      base._attributes = []
-      base.associations = []
-      base.root = true
+    def initialize(object, options={})
+      @object        = object
+      @scope         = options[:scope]
+      @root          = options.fetch(:root, self.class._root)
+      @polymorphic   = options.fetch(:polymorphic, false)
+      @meta_key      = options[:meta_key] || :meta
+      @meta          = options[@meta_key]
+      @wrap_in_array = options[:_wrap_in_array]
+      @only          = options[:only] ? Array(options[:only]) : nil
+      @except        = options[:except] ? Array(options[:except]) : nil
+      @key_format    = options[:key_format]
+      @context       = options[:context]
+      @namespace     = options[:namespace]
+      @prefix        = options.fetch(:prefix, '')
+    end
+    attr_accessor :object, :scope, :root, :meta_key, :meta, :key_format, :context, :polymorphic
+
+    def json_key
+      key = if root == true || root.nil?
+        self.class.root_name
+      else
+        root
+      end
+
+      key_format == :lower_camel && key.present? ? key.camelize(:lower) : key
     end
 
-    def self.attributes(*attributes)
-      @_attributes = @_attributes.concat(attributes)
+    def attributes
+      filter(self.class._attributes.dup).each_with_object({}) do |name, hash|
+        hash[name] = send(name)
+      end
     end
 
-    def self.has_one(associated)
-      @associations << {
-        associated: associated,
-        serializer: ActiveModel::CsverizerFactory
-      }
+    def associations(options={})
+      associations = self.class._associations
+      included_associations = filter(associations.keys)
+      associations.each_with_object({}) do |(name, association), hash|
+        if included_associations.include? name
+          if association.embed_ids?
+            ids = serialize_ids association
+            if association.embed_namespace?
+              hash = hash[association.embed_namespace] ||= {}
+              hash[association.key] = ids
+            else
+              hash[association.key] = ids
+            end
+          elsif association.embed_objects?
+            if association.embed_namespace?
+              hash = hash[association.embed_namespace] ||= {}
+            end
+            hash[association.embedded_key] = serialize association, options
+          end
+        end
+      end
     end
 
-    def self.has_many(associated)
-      @associations << {
-        associated: associated,
-        serializer: ActiveModel::CsvArraySerializer
-      }
+    def filter(keys)
+      if @only
+        keys & @only
+      elsif @except
+        keys - @except
+      else
+        keys
+      end
     end
 
-    attr_reader :object
+    def embedded_in_root_associations
+      associations = self.class._associations
+      included_associations = filter(associations.keys)
+      associations.each_with_object({}) do |(name, association), hash|
+        if included_associations.include? name
+          association_serializer = build_serializer(association)
+          # we must do this always because even if the current association is not
+          # embedded in root, it might have its own associations that are embedded in root
+          hash.merge!(association_serializer.embedded_in_root_associations) do |key, oldval, newval|
+            if oldval.respond_to?(:to_ary)
+              [oldval, newval].flatten.uniq
+            else
+              oldval.merge(newval) { |_, oldval, newval| [oldval, newval].flatten.uniq }
+            end
+          end
+
+          if association.embed_in_root?
+            if association.embed_in_root_key?
+              hash = hash[association.embed_in_root_key] ||= {}
+            end
 
-    def initialize(object, options = {})
-      @object = object
-      @root = options.fetch(:root, self.class.root)
-      @prefix = options.fetch(:prefix, '')
+            serialized_data = association_serializer.serializable_object
+            key = association.root_key
+            if hash.has_key?(key)
+              hash[key].concat(serialized_data).uniq!
+            else
+              hash[key] = serialized_data
+            end
+          end
+        end
+      end
+    end
+
+    def build_serializer(association)
+      object = send(association.name)
+      association.build_serializer(object, association_options_for_serializer(association))
+    end
+
+    def association_options_for_serializer(association)
+      prefix    = association.options[:prefix]
+      namespace = association.options[:namespace] || @namespace || self.namespace
+
+      { scope: scope }.tap do |opts|
+        opts[:namespace] = namespace if namespace
+        opts[:prefix]    = prefix    if prefix
+      end
+    end
+
+    def serialize(association,options={})
+      build_serializer(association).serializable_object(options)
+    end
+
+    def serialize_ids(association)
+      associated_data = send(association.name)
+      if associated_data.respond_to?(:to_ary)
+        associated_data.map { |elem| serialize_id(elem, association) }
+      else
+        serialize_id(associated_data, association) if associated_data
+      end
+    end
+
+    def key_format
+      @key_format || self.class.key_format || CONFIG.key_format
+    end
+
+    def format_key(key)
+      if key_format == :lower_camel
+        key.to_s.camelize(:lower)
+      else
+        key
+      end
+    end
+
+    def convert_keys(hash)
+      Hash[hash.map do |k,v|
+        key = if k.is_a?(Symbol)
+          format_key(k).to_sym
+        else
+          format_key(k)
+        end
+
+        [key ,v]
+      end]
+    end
+
+    attr_writer :serialization_options
+    def serialization_options
+      @serialization_options || {}
+    end
+
+    def serializable_object(options={})
+      self.serialization_options = options
+      return @wrap_in_array ? [] : nil if @object.nil?
+      hash = attributes
+      hash.merge! associations(options)
+      hash = convert_keys(hash) if key_format.present?
+      hash = { :type => type_name(@object), type_name(@object) => hash } if @polymorphic
+      @wrap_in_array ? [hash] : hash
+    end
+    alias_method :serializable_hash, :serializable_object
+
+    def serialize_id(elem, association)
+      id = elem.read_attribute_for_serialization(association.embed_key)
+      association.polymorphic? ? { id: id, type: type_name(elem) } : id
+    end
+
+    def type_name(elem)
+      elem.class.to_s.demodulize.underscore.to_sym
+    end
+
+    def to_csv
+      CSV.generate do |csv|
+        csv << attribute_names
+        to_a.each { |record| csv << record }
+      end
     end
 
     def to_a
@@ -55,13 +327,6 @@ module ActiveModel
       values
     end
 
-    def to_csv
-      CSV.generate do |csv|
-        csv << attribute_names if @root
-        to_a.each { |record| csv << record }
-      end
-    end
-
     def attribute_names
       names = self.class._attributes.collect do |attribute|
         @prefix + attribute.to_s
@@ -71,8 +336,6 @@ module ActiveModel
       end
     end
 
-    private
-
     def read_attribute(name)
       return send(name) if respond_to?(name)
       object.read_attribute_for_serialization(name)
@@ -83,7 +346,7 @@ module ActiveModel
     end
 
     def associated_serializers
-      @associated_serializers ||= self.class.associations.collect do |hash|
+      @associated_serializers ||= self.class._associations.collect do |hash|
         object = read_attribute(hash[:associated])
         hash[:serializer].new(object, prefix: hash[:associated].to_s + '_')
       end

data/lib/active_model/csverizer/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Csverizer
-    VERSION = '0.0.6'
+    VERSION = '0.0.7'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csverizer
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - William Cunningham
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-04 00:00:00.000000000 Z
+date: 2020-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel