Refactoring: extract exposures.

This one reaches many goals at once:

 - Fixes #56: now `exposures` is not a hash table but an array.
 - Due to previous point, tree structure `nested_exposures` based on
   flat hash table with keys like `root_node__node__node` is removed
   because now double exposures don't rewrite previously defined
   so such tree structure is simply incorrect.
   `NestingExposure` with an array of children is introduced instead.
 - Ones who want an old rewriting behavior should manually `unexpose`.
 - Fixes #112
 - Fixes #149: runtime `options` are now wrapped in an `Options` object.
 - Fixes #150: see new `spec/grape_entity/exposure_spec.rb`
 - Fixes #152
 - Fixes #153
 - Fixes #155
 - All exposure configuration and exposing strategies are extracted to
   the separate classes.
 - `key_for`, `name_for` internal methods are removed.
 - Much of the overhead is gone so performance is increased by 20-30%.

Author: marshall-lee

lib/grape_entity.rb

@@ -3,3 +3,5 @@
 require 'grape_entity/version'
 require 'grape_entity/entity'
 require 'grape_entity/delegator'
+require 'grape_entity/exposure'
+require 'grape_entity/options'

lib/grape_entity/condition.rb

@@ -0,0 +1,26 @@
+require 'grape_entity/condition/base'
+require 'grape_entity/condition/block_condition'
+require 'grape_entity/condition/hash_condition'
+require 'grape_entity/condition/symbol_condition'
+
+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
+        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
+        end
+      end
+    end
+  end
+end

lib/grape_entity/condition/base.rb

@@ -0,0 +1,35 @@
+module Grape
+  class Entity
+    module Condition
+      class Base
+        def self.new(inverse, *args, &block)
+          super(inverse).tap { |e| e.setup(*args, &block) }
+        end
+
+        def initialize(inverse = false)
+          @inverse = inverse
+        end
+
+        def ==(other)
+          (self.class == other.class) && (self.inversed? == other.inversed?)
+        end
+
+        def inversed?
+          @inverse
+        end
+
+        def met?(entity, options)
+          !@inverse ? if_value(entity, options) : unless_value(entity, options)
+        end
+
+        def if_value(_entity, _options)
+          fail NotImplementedError
+        end
+
+        def unless_value(entity, options)
+          !if_value(entity, options)
+        end
+      end
+    end
+  end
+end

lib/grape_entity/condition/block_condition.rb

@@ -0,0 +1,21 @@
+module Grape
+  class Entity
+    module Condition
+      class BlockCondition < Base
+        attr_reader :block
+
+        def setup(&block)
+          @block = block
+        end
+
+        def ==(other)
+          super && @block == other.block
+        end
+
+        def if_value(entity, options)
+          entity.exec_with_object(options, &@block)
+        end
+      end
+    end
+  end
+end

lib/grape_entity/condition/hash_condition.rb

@@ -0,0 +1,25 @@
+module Grape
+  class Entity
+    module Condition
+      class HashCondition < Base
+        attr_reader :cond_hash
+
+        def setup(cond_hash)
+          @cond_hash = cond_hash
+        end
+
+        def ==(other)
+          super && @cond_hash == other.cond_hash
+        end
+
+        def if_value(_entity, options)
+          @cond_hash.all? { |k, v| options[k.to_sym] == v }
+        end
+
+        def unless_value(_entity, options)
+          @cond_hash.any? { |k, v| options[k.to_sym] != v }
+        end
+      end
+    end
+  end
+end

lib/grape_entity/condition/symbol_condition.rb

@@ -0,0 +1,21 @@
+module Grape
+  class Entity
+    module Condition
+      class SymbolCondition < Base
+        attr_reader :symbol
+
+        def setup(symbol)
+          @symbol = symbol
+        end
+
+        def ==(other)
+          super && @symbol == other.symbol
+        end
+
+        def if_value(_entity, options)
+          options[symbol]
+        end
+      end
+    end
+  end
+end