refactors API#settings into Grape::Util::HashStack

- settings.add replaced with settings.imbue

Author: Jerry Cheung

.gitignore

@@ -1,5 +1,6 @@
 ## MAC OS
 .DS_Store
+.com.apple.timemachine.supported
 
 ## TEXTMATE
 *.tmproj

lib/grape.rb

@@ -22,6 +22,10 @@ module Auth
       autoload :Digest,	'grape/middleware/auth/digest'
     end
   end
+
+  module Util
+    autoload :HashStack, 'grape/util/hash_stack'
+  end
 end
 
 require 'grape/version'

lib/grape/api.rb

@@ -12,6 +12,7 @@ class << self
       attr_reader :route_set
       attr_reader :versions
       attr_reader :routes
+      attr_reader :settings
 
       def logger(logger = nil)
         if logger
@@ -22,7 +23,7 @@ def logger(logger = nil)
       end
 
       def reset!
-        @settings = [{}]
+        @settings  = Grape::Util::HashStack.new
         @route_set = Rack::Mount::RouteSet.new
         @prototype = nil
       end
@@ -31,40 +32,22 @@ def call(env)
         logger.info "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
         route_set.freeze.call(env)
       end
-      
-      # Settings are a stack, so when we
-      # want to access them they are merged
-      # in the order pushed.
-      def settings
-        @settings.inject({}){|f,h| f.merge!(h); f}
-      end
-      
-      def settings_stack
-        @settings
-      end
-      
+
       # Set a configuration value for this namespace.
       #
       # @param key [Symbol] The key of the configuration variable.
       # @param value [Object] The value to which to set the configuration variable.
       def set(key, value)
-        @settings.last[key.to_sym] = value
+        settings[key.to_sym] = value
       end
-      
+
       # Add to a configuration value for this
       # namespace.
       #
       # @param key [Symbol] The key of the configuration variable.
       # @param value [Object] The value to which to set the configuration variable.
-      def add(key, value)
-        current = @settings.last[key.to_sym]
-        if current.is_a?(Array)
-          current.concat(value)
-        elsif current.is_a?(Hash)
-          current.merge!(value)
-        else
-          @settings.last[key.to_sym] = value
-        end
+      def imbue(key, value)
+        settings.imbue(key, value)
       end
 
       # Define a root URL prefix for your entire
@@ -137,12 +120,12 @@ def default_error_status(new_status = nil)
       def rescue_from(*args, &block)
         if block_given?
           args.each do |arg|
-            add(:rescue_handlers, { arg => block })
+            imbue(:rescue_handlers, { arg => block })
           end
         end
-        add(:rescue_options, args.pop) if args.last.is_a?(Hash)
+        imbue(:rescue_options, args.pop) if args.last.is_a?(Hash)
         set(:rescue_all, true) and return if args.include?(:all)
-        add(:rescued_errors, args)
+        imbue(:rescued_errors, args)
       end
 
       # Allows you to specify a default representation entity for a
@@ -167,12 +150,15 @@ def rescue_from(*args, &block)
       # @option options [Class] :with The entity class that will represent the model.
       def represent(model_class, options)
         raise ArgumentError, "You must specify an entity class in the :with option." unless options[:with] && options[:with].is_a?(Class)
-        add(:representations, model_class => options[:with])
+        imbue(:representations, model_class => options[:with])
       end
 
       # Add helper methods that will be accessible from any
       # endpoint within this namespace (and child namespaces).
       #
+      # When called without a block, all known helpers within this scope
+      # are included.
+      # 
       # @example Define some helpers.
       #     class ExampleAPI < Grape::API
       #       helpers do
@@ -183,12 +169,12 @@ def represent(model_class, options)
       #     end
       def helpers(&block)
         if block_given?
-          m = settings_stack.last[:helpers] || Module.new
+          m = settings.peek[:helpers] || Module.new
           m.class_eval &block
           set(:helpers, m)
         else
           m = Module.new
-          settings_stack.each do |s|
+          settings.stack.each do |s|
             m.send :include, s[:helpers] if s[:helpers]
           end
           m
@@ -272,13 +258,11 @@ def route(methods, paths = ['/'], route_options = {}, &block)
       end
 
       def before(&block)
-        settings_stack.last[:befores] ||= []
-        settings_stack.last[:befores] << block
+        settings.imbue(:befores, [block])
       end
 
       def after(&block) 
-        settings_stack.last[:afters] ||= []
-        settings_stack.last[:afters] << block
+        settings.imbue(:afters, [block])
       end
 
       def get(paths = ['/'], options = {}, &block); route('GET', paths, options, &block) end
@@ -293,7 +277,7 @@ def namespace(space = nil, &block)
             set(:namespace, space.to_s) if space
           end
         else
-          Rack::Mount::Utils.normalize_path(settings_stack.map{|s| s[:namespace]}.join('/'))
+          Rack::Mount::Utils.normalize_path(settings.stack.map{|s| s[:namespace]}.join('/'))
         end
       end
 
@@ -313,17 +297,17 @@ def scope(name = nil, &block)
       # to the current namespace and any children, but
       # not parents.
       #
-      # @param middleware_class [Class] The class of the middleware you'd like to inject.
+      # @param middleware_class [Class] The class of the middleware you'd like
+      #   to inject.
       def use(middleware_class, *args)
-        settings_stack.last[:middleware] ||= []
-        settings_stack.last[:middleware] << [middleware_class, *args]        
+        settings.imbue(:middleware, [[middleware_class, *args]])
       end
 
       # Retrieve an array of the middleware classes
       # and arguments that are currently applied to the
       # application.
       def middleware
-        settings_stack.inject([]){|a,s| a += s[:middleware] if s[:middleware]; a}
+        settings.stack.inject([]){|a,s| a += s[:middleware] if s[:middleware]; a}
       end
 
       # An array of API routes.
@@ -343,18 +327,18 @@ def versions
       def nest(*blocks, &block)
         blocks.reject!{|b| b.nil?}
         if blocks.any?
-          settings_stack << {}
+          settings.push  # create a new context to eval the follow
           instance_eval &block if block_given?
           blocks.each{|b| instance_eval &b}
-          settings_stack.pop
+          settings.pop   # when finished, we pop the context
         else
           instance_eval &block
         end
       end
 
       def aggregate_setting(key)
-        settings_stack.inject([]) do |befores, settings|
-          befores += (settings[key] || [])
+        settings.stack.inject([]) do |aggregate, frame|
+          aggregate += (frame[key] || [])
         end
       end
 
@@ -392,7 +376,13 @@ def build_endpoint(&block)
       def inherited(subclass)
         subclass.reset!
       end
-      
+
+      def inherit(other_stack)
+        # settings stack should know how to merge aggregate keys / values
+        # settings_stack.unshift *other_stack
+        # raise settings_stack.inspect
+      end
+
       def route_set
         @route_set ||= Rack::Mount::RouteSet.new
       end

lib/grape/util/hash_stack.rb

@@ -0,0 +1,87 @@
+module Grape
+  module Util
+    # HashStack is a stack of hashes. When retrieving a value, keys of the top
+    # hash on the stack take precendent over the lower keys.
+    class HashStack
+      # Unmerged array of hashes to represent the stack.
+      # The top of the stack is the last element.
+      attr_reader :stack
+
+      # TODO: handle aggregates
+      def initialize
+        @stack = [{}]
+      end
+
+      # Returns the top hash on the stack
+      def peek
+        @stack.last
+      end
+
+      # Add a new hash to the top of the stack.
+      # 
+      # @param hash [Hash] optional hash to be pushed. Defaults to empty hash
+      # @return [HashStack]
+      def push(hash = {})
+        @stack.push(hash)
+        self
+      end
+
+      def pop
+        @stack.pop
+      end
+
+      # Looks through the stack for the first frame that matches :key
+      # 
+      # @param key [Symbol] key to look for in hash frames
+      # @return value of given key after merging the stack
+      def get(key)
+        (@stack.length - 1).downto(0).each do |i|
+          return @stack[i][key] if @stack[i].key? key
+        end
+        nil
+      end
+      alias_method :[], :get
+
+      # Replace a value on the top hash of the stack.
+      #
+      # @param key [Symbol] The key to set.
+      # @param value [Object] The value to set.
+      def set(key, value)
+        peek[key.to_sym] = value
+      end
+      alias_method :[]=, :set
+
+      # Replace multiple values on the top hash of the stack.
+      # 
+      # @param hash [Hash] Hash of values to be merged in.
+      def update(hash)
+        peek.merge!(hash)
+        self
+      end
+
+      # Adds addition value into the top hash of the stack
+      def imbue(key, value)
+        current = peek[key.to_sym]
+        if current.is_a?(Array)
+          current.concat(value)
+        elsif current.is_a?(Hash)
+          current.merge!(value)
+        else
+          set(key, value)
+        end
+      end
+
+      # Prepend another HashStack's to self
+      def prepend(hash_stack)
+        @stack.unshift *hash_stack.stack
+        self
+      end
+
+      # Concatenate another HashStack's to self
+      def concat(hash_stack)
+        @stack.concat hash_stack.stack
+        self
+      end
+    end
+  end
+end

spec/grape/api_spec.rb

@@ -308,6 +308,32 @@ def app; subject end
     end
   end
 
+  describe 'filters' do
+    it 'should add a before filter' do
+      subject.before { @foo = 'first'  }
+      subject.before { @bar = 'second' }
+      subject.get '/' do
+        "#{@foo} #{@bar}"
+      end
+
+      get '/'
+      last_response.body.should eql 'first second'
+    end
+
+    it 'should add a after filter' do
+      m = double('after mock')
+      subject.after { m.do_something! }
+      subject.after { m.do_something! }
+      subject.get '/' do
+        @var ||= 'default'
+      end
+
+      m.should_receive(:do_something!).exactly(2).times
+      get '/'
+      last_response.body.should eql 'default'
+    end
+  end
+
   context 'format' do
     before do
       subject.get("/foo") { "bar" }
@@ -353,15 +379,19 @@ def call(env)
 
     describe '.middleware' do
       it 'should include middleware arguments from settings' do
-        subject.stub!(:settings_stack).and_return [{:middleware => [[PhonyMiddleware, 'abc', 123]]}]
+        settings = Grape::Util::HashStack.new
+        settings.stub!(:stack).and_return([{:middleware => [[PhonyMiddleware, 'abc', 123]]}])
+        subject.stub!(:settings).and_return(settings)
         subject.middleware.should eql [[PhonyMiddleware, 'abc', 123]]
       end
 
       it 'should include all middleware from stacked settings' do
-        subject.stub!(:settings_stack).and_return [
+        settings = Grape::Util::HashStack.new
+        settings.stub!(:stack).and_return [
           {:middleware => [[PhonyMiddleware, 123],[PhonyMiddleware, 'abc']]},
           {:middleware => [[PhonyMiddleware, 'foo']]}
         ]
+        subject.stub!(:settings).and_return(settings)
 
         subject.middleware.should eql [
           [PhonyMiddleware, 123],
@@ -788,5 +818,4 @@ class CommunicationError < RuntimeError; end
       lambda { get '/uncaught' }.should raise_error(CommunicationError)
     end
   end
-  
 end