grape-entity 0.6.0 → 0.10.1

data/lib/grape_entity/exposure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'grape_entity/exposure/base'
 require 'grape_entity/exposure/represent_exposure'
 require 'grape_entity/exposure/block_exposure'
@@ -10,67 +12,93 @@ require 'grape_entity/condition'
 module Grape
   class Entity
     module Exposure
-      def self.new(attribute, options)
-        conditions = compile_conditions(options)
-        base_args = [attribute, options, conditions]
-
-        if options[:proc]
-          block_exposure = BlockExposure.new(*base_args, &options[:proc])
-        else
-          delegator_exposure = DelegatorExposure.new(*base_args)
-        end
+      class << self
+        def new(attribute, options)
+          conditions = compile_conditions(attribute, options)
+          base_args = [attribute, options, conditions]
 
-        if options[:using]
+          passed_proc = options[:proc]
           using_class = options[:using]
+          format_with = options[:format_with]
 
-          if options[:proc]
-            RepresentExposure.new(*base_args, using_class, block_exposure)
+          if using_class
+            build_class_exposure(base_args, using_class, passed_proc)
+          elsif passed_proc
+            build_block_exposure(base_args, passed_proc)
+          elsif format_with
+            build_formatter_exposure(base_args, format_with)
+          elsif options[:nesting]
+            build_nesting_exposure(base_args)
           else
-            RepresentExposure.new(*base_args, using_class, delegator_exposure)
+            build_delegator_exposure(base_args)
           end
+        end
 
-        elsif options[:proc]
-          block_exposure
+        private
 
-        elsif options[:format_with]
-          format_with = options[:format_with]
+        def compile_conditions(attribute, options)
+          if_conditions = [
+            options[:if_extras],
+            options[:if]
+          ].compact.flatten.map { |cond| Condition.new_if(cond) }
 
-          if format_with.is_a? Symbol
-            FormatterExposure.new(*base_args, format_with)
-          elsif format_with.respond_to? :call
-            FormatterBlockExposure.new(*base_args, &format_with)
-          end
+          unless_conditions = [
+            options[:unless_extras],
+            options[:unless]
+          ].compact.flatten.map { |cond| Condition.new_unless(cond) }
 
-        elsif options[:nesting]
-          NestingExposure.new(*base_args)
+          unless_conditions << expose_nil_condition(attribute, options) if options[:expose_nil] == false
 
-        else
-          delegator_exposure
+          if_conditions + unless_conditions
         end
-      end
 
-      def self.compile_conditions(options)
-        if_conditions = []
-        unless options[:if_extras].nil?
-          if_conditions.concat(options[:if_extras])
+        def expose_nil_condition(attribute, options)
+          Condition.new_unless(
+            proc do |object, _options|
+              if options[:proc].nil?
+                delegator = Delegator.new(object)
+                if is_a?(Grape::Entity) && delegator.accepts_options?
+                  delegator.delegate(attribute, **self.class.delegation_opts).nil?
+                else
+                  delegator.delegate(attribute).nil?
+                end
+              else
+                exec_with_object(options, &options[:proc]).nil?
+              end
+            end
+          )
         end
-        if_conditions << options[:if] unless options[:if].nil?
 
-        if_conditions.map! do |cond|
-          Condition.new_if cond
+        def build_class_exposure(base_args, using_class, passed_proc)
+          exposure =
+            if passed_proc
+              build_block_exposure(base_args, passed_proc)
+            else
+              build_delegator_exposure(base_args)
+            end
+
+          RepresentExposure.new(*base_args, using_class, exposure)
+        end
+
+        def build_formatter_exposure(base_args, format_with)
+          if format_with.is_a? Symbol
+            FormatterExposure.new(*base_args, format_with)
+          elsif format_with.respond_to?(:call)
+            FormatterBlockExposure.new(*base_args, &format_with)
+          end
         end
 
-        unless_conditions = []
-        unless options[:unless_extras].nil?
-          unless_conditions.concat(options[:unless_extras])
+        def build_nesting_exposure(base_args)
+          NestingExposure.new(*base_args)
         end
-        unless_conditions << options[:unless] unless options[:unless].nil?
 
-        unless_conditions.map! do |cond|
-          Condition.new_unless cond
+        def build_block_exposure(base_args, passed_proc)
+          BlockExposure.new(*base_args, &passed_proc)
         end
 
-        if_conditions + unless_conditions
+        def build_delegator_exposure(base_args)
+          DelegatorExposure.new(*base_args)
+        end
       end
     end
   end

data/lib/grape_entity/options.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
 module Grape
   class Entity
     class Options
+      extend Forwardable
+
       attr_reader :opts_hash
 
+      def_delegators :opts_hash, :dig, :key?, :fetch, :[], :empty
+
       def initialize(opts_hash = {})
         @opts_hash = opts_hash
         @has_only = !opts_hash[:only].nil?
@@ -11,54 +19,33 @@ module Grape
         @should_return_key_cache = {}
       end
 
-      def [](key)
-        @opts_hash[key]
-      end
+      def merge(new_opts)
+        return self if new_opts.empty?
 
-      def fetch(*args)
-        @opts_hash.fetch(*args)
-      end
+        merged = if new_opts.instance_of? Options
+                   @opts_hash.merge(new_opts.opts_hash)
+                 else
+                   @opts_hash.merge(new_opts)
+                 end
 
-      def key?(key)
-        @opts_hash.key? key
-      end
-
-      def merge(new_opts)
-        if new_opts.empty?
-          self
-        else
-          merged = if new_opts.instance_of? Options
-                     @opts_hash.merge(new_opts.opts_hash)
-                   else
-                     @opts_hash.merge(new_opts)
-                   end
-          Options.new(merged)
-        end
+        Options.new(merged)
       end
 
       def reverse_merge(new_opts)
-        if new_opts.empty?
-          self
-        else
-          merged = if new_opts.instance_of? Options
-                     new_opts.opts_hash.merge(@opts_hash)
-                   else
-                     new_opts.merge(@opts_hash)
-                   end
-          Options.new(merged)
-        end
-      end
+        return self if new_opts.empty?
 
-      def empty?
-        @opts_hash.empty?
+        merged = if new_opts.instance_of? Options
+                   new_opts.opts_hash.merge(@opts_hash)
+                 else
+                   new_opts.merge(@opts_hash)
+                 end
+
+        Options.new(merged)
       end
 
       def ==(other)
-        @opts_hash == if other.is_a? Options
-                        other.opts_hash
-                      else
-                        other
-                      end
+        other_hash = other.is_a?(Options) ? other.opts_hash : other
+        @opts_hash == other_hash
       end
 
       def should_return_key?(key)
@@ -66,7 +53,7 @@ module Grape
 
         only = only_fields.nil? ||
                only_fields.key?(key)
-        except = except_fields && except_fields.key?(key) &&
+        except = except_fields&.key?(key) &&
                  except_fields[key] == true
         only && !except
       end
@@ -96,36 +83,35 @@ module Grape
       end
 
       def with_attr_path(part)
+        return yield unless part
+
         stack = (opts_hash[:attr_path] ||= [])
-        if part
-          stack.push part
-          result = yield
-          stack.pop
-          result
-        else
-          yield
-        end
+        stack.push part
+        result = yield
+        stack.pop
+        result
       end
 
       private
 
       def build_for_nesting(key)
-        new_opts_hash = opts_hash.dup
-        new_opts_hash.delete(:collection)
-        new_opts_hash[:root] = nil
-        new_opts_hash[:only] = only_fields(key)
-        new_opts_hash[:except] = except_fields(key)
-        new_opts_hash[:attr_path] = opts_hash[:attr_path]
-
-        Options.new(new_opts_hash)
+        Options.new(
+          opts_hash.dup.reject { |current_key| current_key == :collection }.merge(
+            root: nil,
+            only: only_fields(key),
+            except: except_fields(key),
+            attr_path: opts_hash[:attr_path]
+          )
+        )
       end
 
       def build_symbolized_hash(attribute, hash)
-        if attribute.is_a?(Hash)
+        case attribute
+        when Hash
           attribute.each do |attr, nested_attrs|
             hash[attr.to_sym] = build_symbolized_hash(nested_attrs, {})
           end
-        elsif attribute.is_a?(Array)
+        when Array
           return attribute.each { |x| build_symbolized_hash(x, {}) }
         else
           hash[attribute.to_sym] = true

data/lib/grape_entity/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module GrapeEntity
-  VERSION = '0.6.0'.freeze
+  VERSION = '0.10.1'
 end

data/lib/grape_entity.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/version'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/hash/reverse_merge'
@@ -7,3 +9,4 @@ require 'grape_entity/entity'
 require 'grape_entity/delegator'
 require 'grape_entity/exposure'
 require 'grape_entity/options'
+require 'grape_entity/deprecated'