Refactor and simplify various modules and classes

Author: DmitryTsepelev

lib/grape_entity/condition.rb

@@ -8,19 +8,26 @@
 module Grape
   class Entity
     module Condition
-      def self.new_if(arg)
-        case arg
-        when Hash then HashCondition.new false, arg
-        when Proc then BlockCondition.new false, &arg
-        when Symbol then SymbolCondition.new false, arg
+      class << self
+        def new_if(arg)
+          condition(false, arg)
         end
-      end
 
-      def self.new_unless(arg)
-        case arg
-        when Hash then HashCondition.new true, arg
-        when Proc then BlockCondition.new true, &arg
-        when Symbol then SymbolCondition.new true, arg
+        def new_unless(arg)
+          condition(true, arg)
+        end
+
+        private
+
+        def condition(inverse, arg)
+          condition_klass =
+            case arg
+            when Hash then HashCondition
+            when Proc then BlockCondition
+            when Symbol then SymbolCondition
+            end
+
+          condition_klass.new(inverse, arg)
         end
       end
     end

lib/grape_entity/condition/block_condition.rb

@@ -6,7 +6,7 @@ module Condition
       class BlockCondition < Base
         attr_reader :block
 
-        def setup(&block)
+        def setup(block)
           @block = block
         end
 

lib/grape_entity/delegator.rb

@@ -10,15 +10,14 @@ module Grape
   class Entity
     module Delegator
       def self.new(object)
-        if object.is_a?(Hash)
-          HashObject.new object
-        elsif defined?(OpenStruct) && object.is_a?(OpenStruct)
-          OpenStructObject.new object
-        elsif object.respond_to? :fetch, true
-          FetchableObject.new object
-        else
-          PlainObject.new object
-        end
+        delegator_klass =
+          if object.is_a?(Hash) then HashObject
+          elsif defined?(OpenStruct) && object.is_a?(OpenStruct) then OpenStructObject
+          elsif object.respond_to?(:fetch, true) then FetchableObject
+          else PlainObject
+          end
+
+        delegator_klass.new(object)
       end
     end
   end

lib/grape_entity/entity.rb

@@ -451,12 +451,8 @@ def inspect
 
     def initialize(object, options = {})
       @object = object
-      @delegator = Delegator.new object
-      @options = if options.is_a? Options
-                   options
-                 else
-                   Options.new options
-                 end
+      @delegator = Delegator.new(object)
+      @options = options.is_a?(Options) ? options: Options.new(options)
     end
 
     def root_exposures

lib/grape_entity/exposure.rb

@@ -12,63 +12,74 @@
 module Grape
   class Entity
     module Exposure
-      def self.new(attribute, options)
-        conditions = compile_conditions(options)
-        base_args = [attribute, options, conditions]
+      class << self
+        def 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
-
-        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(options)
+          if_conditions = [
+            options[:if_extras],
+            options[:if]
+          ].compact.flatten.map { |cond| Condition.new_if(cond) }
+
+          unless_conditions = [
+            options[:unless_extras],
+            options[:unless]
+          ].compact.flatten.map { |cond| Condition.new_unless(cond) }
+
+          if_conditions + unless_conditions
+        end
+
+        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
+          elsif format_with.respond_to?(:call)
             FormatterBlockExposure.new(*base_args, &format_with)
           end
+        end
 
-        elsif options[:nesting]
+        def build_nesting_exposure(base_args)
           NestingExposure.new(*base_args)
-
-        else
-          delegator_exposure
         end
-      end
-
-      def self.compile_conditions(options)
-        if_conditions = []
-        if_conditions.concat(options[:if_extras]) unless options[:if_extras].nil?
-        if_conditions << options[:if] unless options[:if].nil?
 
-        if_conditions.map! do |cond|
-          Condition.new_if cond
+        def build_block_exposure(base_args, passed_proc)
+          BlockExposure.new(*base_args, &passed_proc)
         end
 
-        unless_conditions = []
-        unless_conditions.concat(options[:unless_extras]) unless options[:unless_extras].nil?
-        unless_conditions << options[:unless] unless options[:unless].nil?
-
-        unless_conditions.map! do |cond|
-          Condition.new_unless cond
+        def build_delegator_exposure(base_args)
+          DelegatorExposure.new(*base_args)
         end
-
-        if_conditions + unless_conditions
       end
     end
   end

lib/grape_entity/exposure/nesting_exposure.rb

@@ -31,39 +31,27 @@ def valid?(entity)
         end
 
         def value(entity, options)
-          new_options = nesting_options_for(options)
-          output = OutputBuilder.new(entity)
-
-          normalized_exposures(entity, new_options).each_with_object(output) do |exposure, out|
-            exposure.with_attr_path(entity, new_options) do
-              result = exposure.value(entity, new_options)
-              out.add(exposure, result)
-            end
+          map_entity_exposures(entity, options) do |exposure, nested_options|
+            exposure.value(entity, nested_options)
           end
         end
 
-        def valid_value_for(key, entity, options)
-          new_options = nesting_options_for(options)
-
-          result = nil
-          normalized_exposures(entity, new_options).select { |e| e.key(entity) == key }.each do |exposure|
-            exposure.with_attr_path(entity, new_options) do
-              result = exposure.valid_value(entity, new_options)
-            end
+        def serializable_value(entity, options)
+          map_entity_exposures(entity, options) do |exposure, nested_options|
+            exposure.serializable_value(entity, nested_options)
           end
-          result
         end
 
-        def serializable_value(entity, options)
+        def valid_value_for(key, entity, options)
           new_options = nesting_options_for(options)
-          output = OutputBuilder.new(entity)
 
-          normalized_exposures(entity, new_options).each_with_object(output) do |exposure, out|
+          key_exposures = normalized_exposures(entity, new_options).select { |e| e.key(entity) == key }
+
+          key_exposures.map do |exposure|
             exposure.with_attr_path(entity, new_options) do
-              result = exposure.serializable_value(entity, new_options)
-              out.add(exposure, result)
+              exposure.valid_value(entity, new_options)
             end
-          end
+          end.last
         end
 
         # if we have any nesting exposures with the same name.
@@ -122,6 +110,18 @@ def normalized_exposures(entity, options)
             end
           end
         end
+
+        def map_entity_exposures(entity, options)
+          new_options = nesting_options_for(options)
+          output = OutputBuilder.new(entity)
+
+          normalized_exposures(entity, new_options).each_with_object(output) do |exposure, out|
+            exposure.with_attr_path(entity, new_options) do
+              result = yield(exposure, new_options)
+              out.add(exposure, result)
+            end
+          end
+        end
       end
     end
   end