mock_server 0.4.1 → 0.4.2

data/lib/mock_server/playback.rb

@@ -8,114 +8,116 @@ unless defined? MockServer::Store
   require 'mock_server/store/global'
 end
 
-module MockServer
-  class Playback
-    include MockServer::Utils
-    include MockServer::Store
-
-    def initialize(app, opt = {})
-      @app = app
-      @options = mock_server_options_merge(opt)
-    end
-
-    def call(env)
-      @options = self.mock_server_options_read
-
-      verbose(env) if @options[:verbose]
-      return @app.call(env) unless @options[:routes] and
-                                   lazy_match @options[:routes], env["PATH_INFO"]
+class MockServer::Playback
+  include MockServer::Utils
+  include MockServer::Store
 
-      @request = Rack::Request.new(env)
+  def initialize(app, opt = {})
+    @app = app
+    @options = mock_server_options_merge(opt)
+  end
 
-      @options[:requests_stack] << @request.path
+  def call(env)
+    @options = self.mock_server_options_read
 
-      @data = load_data
+    verbose(env) if @options[:verbose]
+    return @app.call(env) unless matchable_request?(env)
 
-      record = match_request
+    @request = Rack::Request.new(env)
+    @options[:requests_stack] << @request.path
+    @data = load_data
 
-      response = if record
-        @options[:success_stack] << @request.path
-        @options[:matcher_exceptions].clear
+    response = build_response
+    self.mock_server_options_write(@options)
+    response
+  end
 
-        response = record[:response]
-        [response[:status], response[:headers], [response[:body]]]
-      else
-        error = { @request.path => "Couldn't match #{@request.request_method} #{@request.path}" }
-        @options[:errors_stack] << error
-        [404, {}, ['RECORD NOT FOUND!']]
-      end
+  private
 
-      self.mock_server_options_write(@options)
-      response
+  def build_response
+    if record = match_request
+      return_record(record)
+    else
+      return_error
     end
+  end
 
-    private
+  def return_record(record)
+    @options[:success_stack] << @request.path
+    @options[:matcher_exceptions].clear
+    response = record[:response]
+    [response[:status], response[:headers], [response[:body]]]
+  end
 
-    def match_request
-      request = Hashie::Mash.new hashified_request
+  def return_error
+    error = { @request.path => "Couldn't match #{@request.request_method} #{@request.path}" }
+    @options[:errors_stack] << error
+    [404, {}, ['RECORD NOT FOUND!']]
+  end
 
-      # Filter out data records by path and method
-      data = filter_records(request)
+  def match_request
+    request = Hashie::Mash.new hashified_request
 
-      matchers = filter_matchers(request)
+    # Filter out data records by path and method
+    records = filter_records(request)
 
-      data = false
-      matchers.detect { |matcher|
-        # Match the request with a record by validating against the matcher if any.
-        data = @data.detect { |entry|
-          recorded_request  = Hashie::Mash.new entry[:request]
-          recorded_response = entry[:response].dup
+    matchers = filter_matchers(request)
 
-          recorded_response[:body] = JSON.parse(recorded_response[:body]) rescue recorded_response[:body]
-          recorded_response = Hashie::Mash.new recorded_response
+    record = false
+    matchers.detect { |matcher|
+      # Match the request with a record by validating against the matcher if any.
+      record = records.detect { |entry|
+        recorded_request  = Hashie::Mash.new entry[:request]
+        recorded_response = entry[:response].dup
 
-          test_request_and_matcher(matcher, request, recorded_request, recorded_response)
-        }
-      }
-      data
-    end
+        recorded_response[:body] = JSON.parse(recorded_response[:body]) rescue recorded_response[:body]
+        recorded_response = Hashie::Mash.new recorded_response
 
-    def filter_matchers(request)
-      @options[:matchers].select { |match|
-        request[:method].to_s.upcase == match[:method].to_s.upcase and request[:path] == match[:path]
+        test_request_and_matcher(matcher, request, recorded_request, recorded_response)
       }
-    end
+    }
+    record
+  end
 
-    def filter_records(request)
-      @data.select { |record|
-        record[:request][:path] == request[:path] and record[:request][:method] == request[:method]
-      }
-    end
+  def filter_matchers(request)
+    @options[:matchers].select { |match|
+      request[:method].to_s.upcase == match[:method].to_s.upcase and request[:path] == match[:path]
+    }
+  end
 
-    def test_request_and_matcher(matcher, request, recorded_request, recorded_response)
-      return true if matcher[:matcher].nil?
-      begin
-        matcher[:matcher].call(request, recorded_request, recorded_response) == true
-      rescue => matcher_err
-        store_matcher_exception(matcher_err)
-        false
-      end
-    end
+  def filter_records(request)
+    @data.select { |record|
+      record[:request][:path] == request[:path] and record[:request][:method] == request[:method]
+    }
+  end
 
-    def store_matcher_exception(exception)
-      @options[:matcher_exceptions] << exception
+  def test_request_and_matcher(matcher, request, recorded_request, recorded_response)
+    return true if matcher[:matcher].nil?
+    begin
+      matcher[:matcher].call(request, recorded_request, recorded_response) == true
+    rescue => matcher_err
+      store_matcher_exception(matcher_err)
+      false
     end
+  end
 
-    def load_data
-      FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
+  def store_matcher_exception(exception)
+    @options[:matcher_exceptions] << exception
+  end
 
-      data = []
+  def load_data
+    FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
 
-      @options[:record_filenames].map do |filename|
-        file_path = File.join( @options[:path], filename + '.yml' )
-        content   = File.open(file_path).read
-        compiled  = ERB.new(content).result
-        parsed    = YAML.load(compiled)
-        data     += parsed
-      end
+    data = []
 
-      data
+    @options[:record_filenames].map do |filename|
+      file_path = File.join( @options[:path], filename + '.yml' )
+      content   = File.open(file_path).read
+      compiled  = ERB.new(content).result
+      parsed    = YAML.load(compiled)
+      data     += parsed
     end
 
+    data
   end
 end

data/lib/mock_server/record.rb

@@ -5,63 +5,59 @@ unless defined? MockServer::Store
   require 'mock_server/store/global'
 end
 
-module MockServer
-  class Record
-    include MockServer::Utils
-    include MockServer::Store
+class MockServer::Record
+  include MockServer::Utils
+  include MockServer::Store
 
-    def initialize(app, opt = {})
-      @app = app
-      @options = mock_server_options_merge(opt)
-    end
+  def initialize(app, opt = {})
+    @app = app
+    @options = mock_server_options_merge(opt)
+  end
 
-    def call(env)
-      @options = self.mock_server_options_read
+  def call(env)
+    @options = self.mock_server_options_read
 
-      verbose(env) if @options[:verbose]
-      return @app.call(env) unless @options[:routes] and
-                                   lazy_match @options[:routes], env["PATH_INFO"]
+    verbose(env) if @options[:verbose]
+    return @app.call(env) unless matchable_request?(env)
 
-      @request = Rack::Request.new(env)
-      @data = load_data
+    @request = Rack::Request.new(env)
+    @data = load_data
 
-      @app.call(env).tap do |status, header, response|
-        record_response(status, header, response)
-        self.mock_server_options_write(@options)
-        response
-      end
+    @app.call(env).tap do |status, header, response|
+      record_response(status, header, response)
+      self.mock_server_options_write(@options)
+      response
     end
-  
-    private
-    
-    def record_response(status, header, response)
-      request = hashified_request
+  end
 
-      @data << { :request => request, :response => hashify_response(status, header, response) }
-      save_data(@data)
-    end
+  private
 
-    def records_path
-      File.join( @options[:path], @options[:filename] + '.yml' )
-    end
+  def record_response(status, header, response)
+    request = hashified_request
 
-    def save_data(data)
-      File.open(records_path, 'w') do |f|
-        YAML.dump(data, f)
-      end
+    @data << { :request => request, :response => hashify_response(status, header, response) }
+    save_data(@data)
+  end
+
+  def records_path
+    File.join( @options[:path], @options[:filename] + '.yml' )
+  end
+
+  def save_data(data)
+    File.open(records_path, 'w') do |f|
+      YAML.dump(data, f)
     end
+  end
 
-    def load_data
-      FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
+  def load_data
+    FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
 
-      data = YAML.load_file(records_path) rescue []
+    data = YAML.load_file(records_path) rescue []
 
-      if data.is_a? Array
-        data
-      else
-        []
-      end
+    if data.is_a? Array
+      data
+    else
+      []
     end
-
   end
 end

data/lib/mock_server/spec/helpers.rb

@@ -2,288 +2,300 @@ unless defined? MockServer::Store
   require 'mock_server/store/global'
 end
 
-module MockServer
-  module Spec
-    module Helpers
-      include MockServer::Store
+module MockServer::Spec
+  module Helpers
+    include MockServer::Store
 
+    # Public: Inspect mock server options
+    #
+    # Returns a String.
+    def mock_server_inspect
+      self.mock_server_options_read.inspect
+    end
 
-      # Public: Inspect mock server options
-      #
-      # Returns a String.
-      def mock_server_inspect
-        mock_server_options.inspect
-      end
+    # Public: Overwrite or initialize the list of fixtures
+    #
+    # *arguments - Filename...
+    #
+    # Examples
+    #
+    #    mock_server_use_record(:users, :comments)
+    #
+    def mock_server_use_record(*arguments)
+      mock_server_options_set(:record_filenames, arguments)
+    end
 
-      # Public: Overwrite or initialize the list of fixtures
-      #
-      # *arguments - Filename...
-      #
-      # Examples
-      #
-      #    mock_server_use_record(:users, :comments)
-      #
-      def mock_server_use_record(*arguments)
-        mock_server_options_set(:record_filenames, arguments)
-      end
+    # Public: Add fixtures to the list of fixtures
+    #
+    # *arguments - Filename...
+    #
+    # Examples
+    #
+    #    mock_server_add_record(:users, :comments)
+    #
+    def mock_server_add_record(*arguments)
+      config = (mock_server_options_fetch(:record_filenames, []) + arguments)
+      mock_server_options_set(:record_filenames, config)
+    end
 
-      # Public: Add fixtures to the list of fixtures
-      #
-      # *arguments - Filename...
-      #
-      # Examples
-      #
-      #    mock_server_add_record(:users, :comments)
-      #
-      def mock_server_add_record(*arguments)
-        config = (mock_server_options_fetch(:record_filenames, []) + arguments)
-        mock_server_options_set(:record_filenames, config)
-      end
+    # Public: Set the path of fixtures files
+    #
+    # path - Sting of the fixtures path
+    #
+    # Examples
+    #
+    #    mock_server_set_fixture_path('fixtures/records/')
+    #
+    def mock_server_set_fixture_path(path)
+      mock_server_options_set(:path, path)
+    end
 
-      # Public: Set the path of fixtures files
-      #
-      # path - Sting of the fixtures path
-      #
-      # Examples
-      #
-      #    mock_server_set_fixture_path('fixtures/records/')
-      #
-      def mock_server_set_fixture_path(path)
-        mock_server_options_set(:path, path)
-      end
+    # Public: Enabled MockServer on a given routes.
+    # Accept unix-directory like */** catch all.
+    #
+    # *arguments - Sting of the fixtures path
+    #
+    # Examples
+    #
+    #    mock_server_enable_routes('/api/2/**', '/api/verify')
+    #
+    def mock_server_enable_routes(*paths)
+      routes = mock_server_options_fetch(:routes, []) + paths
+      mock_server_options_set(:routes, routes)
+    end
 
-      # Public: Enabled MockServer on a given routes.
-      # Accept unix-directory like */** catch all.
-      #
-      # *arguments - Sting of the fixtures path
-      #
-      # Examples
-      #
-      #    mock_server_enable_routes('/api/2/**', '/api/verify')
-      #
-      def mock_server_enable_routes(*paths)
-        routes = mock_server_options_fetch(:routes, []) + paths
-        mock_server_options_set(:routes, routes)
-      end
+    # Public: Disable MockServer on a given routes.
+    #
+    # *paths - Sting of the fixtures path
+    #
+    # Examples
+    #
+    #    mock_server_disable_path('/api/2/**', '/api/verify')
+    #
+    def mock_server_disable_path(*paths)
+      routes = mock_server_options_fetch(:routes, []) - paths
+      mock_server_options_set(:routes, routes.flatten)
+    end
 
-      # Public: Disable MockServer on a given routes.
-      #
-      # *paths - Sting of the fixtures path
-      #
-      # Examples
-      #
-      #    mock_server_disable_path('/api/2/**', '/api/verify')
-      #
-      def mock_server_disable_path(*paths)
-        routes = mock_server_options_fetch(:routes, []) - paths
-        mock_server_options_set(:routes, routes.flatten)
-      end
+    # Public: Disable all routes being server by MockServer
+    #
+    #
+    # Examples
+    #
+    #    mock_server_disable_all_routes!
+    #
+    def mock_server_disable_all_routes!
+      mock_server_options_set(:routes, [])
+    end
 
-      # Public: Disable all routes being server by MockServer
-      #
-      #
-      # Examples
-      #
-      #    mock_server_disable_all_routes!
-      #
-      def mock_server_disable_all_routes!
-        mock_server_options_set(:routes, [])
-      end
+    # Public: Register a matcher on a GET request for a given route.
+    #
+    # path    - Relative HTTP path to match
+    # &block  - Optional block for complex matching on the request
+    #
+    # Examples
+    #
+    #    mock_server_get('/api/2/account')
+    #
+    #    mock_server_get('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
+    #
+    def mock_server_get(path, &block)
+      mock_server_request :get, path, block
+    end
 
-      # Public: Register a matcher on a GET request for a given route.
-      #
-      # path    - Relative HTTP path to match
-      # &block  - Optional block for complex matching on the request
-      #
-      # Examples
-      #
-      #    mock_server_get('/api/2/account')
-      #
-      #    mock_server_get('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
-      #
-      def mock_server_get(path, &block)
-        mock_server_request :get, path, block
-      end
+    # Public: Register a matcher on a POST request for a given route.
+    #
+    # path    - Relative HTTP path to match
+    # &block  - Optional block for complex matching on the request
+    #
+    # Examples
+    #
+    #    mock_server_post('/api/2/account')
+    #
+    #    mock_server_post('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
+    #
+    def mock_server_post(path, &block)
+      mock_server_request :post, path, block
+    end
 
-      # Public: Register a matcher on a POST request for a given route.
-      #
-      # path    - Relative HTTP path to match
-      # &block  - Optional block for complex matching on the request
-      #
-      # Examples
-      #
-      #    mock_server_post('/api/2/account')
-      #
-      #    mock_server_post('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
-      #
-      def mock_server_post(path, &block)
-        mock_server_request :post, path, block
-      end
+    # Public: Register a matcher on a PUT request for a given route.
+    #
+    # path    - Relative HTTP path to match
+    # &block  - Optional block for complex matching on the request
+    #
+    # Examples
+    #
+    #    mock_server_put('/api/2/account')
+    #
+    #    mock_server_put('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
+    #
+    def mock_server_put(path, &block)
+      mock_server_request :put, path, block
+    end
 
-      # Public: Register a matcher on a PUT request for a given route.
-      #
-      # path    - Relative HTTP path to match
-      # &block  - Optional block for complex matching on the request
-      #
-      # Examples
-      #
-      #    mock_server_put('/api/2/account')
-      #
-      #    mock_server_put('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
-      #
-      def mock_server_put(path, &block)
-        mock_server_request :put, path, block
-      end
+    # Public: Register a matcher on a PATCH request for a given route.
+    #
+    # path    - Relative HTTP path to match
+    # &block  - Optional block for complex matching on the request
+    #
+    # Examples
+    #
+    #    mock_server_patch('/api/2/account')
+    #
+    #    mock_server_patch('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
+    #
+    def mock_server_patch(path, &block)
+      mock_server_request :patch, path, block
+    end
 
-      # Public: Register a matcher on a DELETE request for a given route.
-      #
-      # path    - Relative HTTP path to match
-      # &block  - Optional block for complex matching on the request
-      #
-      # Examples
-      #
-      #    mock_server_delete('/api/2/account')
-      #
-      #    mock_server_delete('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
-      #
-      def mock_server_delete(path, &block)
-        mock_server_request :delete, path, block
-      end
+    # Public: Register a matcher on a DELETE request for a given route.
+    #
+    # path    - Relative HTTP path to match
+    # &block  - Optional block for complex matching on the request
+    #
+    # Examples
+    #
+    #    mock_server_delete('/api/2/account')
+    #
+    #    mock_server_delete('/api/2/account') { |request, recorded_request| request.body == recorded_request.body }
+    #
+    def mock_server_delete(path, &block)
+      mock_server_request :delete, path, block
+    end
 
-      # Public: Clear all the matchers
-      #
-      def mock_server_clear_matchers!
-        mock_server_options_set(:matchers, [])
-      end
+    # Public: Clear all the matchers
+    #
+    def mock_server_clear_matchers!
+      mock_server_options_set(:matchers, [])
+    end
 
-      # Public: Retrive the MockServer request stack.
-      #
-      # Return array of request path.
-      def mock_server_requests_stack
-        mock_server_options_fetch(:requests_stack, [])
-      end
+    # Public: Retrive the MockServer request stack.
+    #
+    # Return array of request path.
+    def mock_server_requests_stack
+      mock_server_options_fetch(:requests_stack, [])
+    end
 
-      # Public: Clear the MockServer request stack.
-      def mock_server_requests_stack_clear!
-         mock_server_options_set(:requests_stack, [])
-      end
+    # Public: Clear the MockServer request stack.
+    def mock_server_requests_stack_clear!
+       mock_server_options_set(:requests_stack, [])
+    end
 
-      # Public: Retrive the MockServer request stack.
-      #
-      # Return array of request path.
-      def mock_server_errors_stack
-        mock_server_options_fetch(:errors_stack, [])
-      end
+    # Public: Retrive the MockServer request stack.
+    #
+    # Return array of request path.
+    def mock_server_errors_stack
+      mock_server_options_fetch(:errors_stack, [])
+    end
 
-      # Public: Retrive the MockServer errors request stack.
-      # i.e.: path being register for being serve by MockServer, but
-      # no suitable matcher was found to serve the request will be
-      # added to the error stack
-      #
-      # Return array of errors.
-      def mock_server_errors_stack_clear!
-        mock_server_options_set(:errors_stack, [])
-      end
+    # Public: Retrive the MockServer errors request stack.
+    # i.e.: path being register for being serve by MockServer, but
+    # no suitable matcher was found to serve the request will be
+    # added to the error stack
+    #
+    # Return array of errors.
+    def mock_server_errors_stack_clear!
+      mock_server_options_set(:errors_stack, [])
+    end
 
-      # Public: Retrive the MockServer successful request stack.
-      #
-      # Return array of successful response stack.
-      def mock_server_success_stack
-        mock_server_options_fetch(:success_stack, [])
-      end
+    # Public: Retrive the MockServer successful request stack.
+    #
+    # Return array of successful response stack.
+    def mock_server_success_stack
+      mock_server_options_fetch(:success_stack, [])
+    end
 
-      # Public: Clear the MockServer successful request stack.
-      def mock_server_success_stack_clear!
-        mock_server_options_set(:success_stack, [])
-      end
+    # Public: Clear the MockServer successful request stack.
+    def mock_server_success_stack_clear!
+      mock_server_options_set(:success_stack, [])
+    end
 
-      # Public: Clear the MockServer response stack.
-      #
-      # alias:
-      #
-      #   mock_server_requests_stack_clear!
-      #   mock_server_success_stack_clear!
-      #   mock_server_errors_stack_clear!
-      #
-      def mock_server_response_stack_clear!
-        mock_server_requests_stack_clear!
-        mock_server_success_stack_clear!
-        mock_server_errors_stack_clear!
-      end
+    # Public: Clear the MockServer response stack.
+    #
+    # alias:
+    #
+    #   mock_server_requests_stack_clear!
+    #   mock_server_success_stack_clear!
+    #   mock_server_errors_stack_clear!
+    #
+    def mock_server_response_stack_clear!
+      mock_server_requests_stack_clear!
+      mock_server_success_stack_clear!
+      mock_server_errors_stack_clear!
+    end
 
-      # Public: Clear the MockServer state.
-      #
-      # alias:
-      #
-      #   mock_server_response_stack_clear!
-      #   mock_server_clear_matchers!
-      #   mock_server_disable_all_routes!
-      #
-      def mock_server_reset!
-        mock_server_response_stack_clear!
-        mock_server_clear_matchers!
-        mock_server_disable_all_routes!
-      end
+    # Public: Clear the MockServer state.
+    #
+    # alias:
+    #
+    #   mock_server_response_stack_clear!
+    #   mock_server_clear_matchers!
+    #   mock_server_disable_all_routes!
+    #
+    def mock_server_reset!
+      mock_server_response_stack_clear!
+      mock_server_clear_matchers!
+      mock_server_disable_all_routes!
+    end
 
-      # Public: Utility helper to reraise errors catch inside the matchers block
-      #
-      def mock_server_reraise_matcher_exceptions
-        mock_server_options_fetch(:matcher_exceptions, []).each do |exception|
-          raise exception
-        end
+    # Public: Utility helper to reraise errors catch inside the matchers block
+    #
+    def mock_server_reraise_matcher_exceptions
+      mock_server_options_fetch(:matcher_exceptions, []).each do |exception|
+        raise exception
       end
+    end
 
-      protected
+    protected
 
-      # Internal: Register a matcher on a given route for playback
-      #
-      # method  - HTTP verb to register
-      # path    - Relative HTTP path to match
-      # matcher - Optional proc for complex matching on the request
-      #
-      # Examples
-      #
-      #    mock_server_request(:get, '/api/2/account')
-      #
-      #    mock_server_request(:get, '/api/2/account', lambda {|request, recorded_request| request.body == recorded_request.body } )
-      #
-      def mock_server_request(method, path, matcher)
-        add_mock_server_matcher({ :method => method, :path => path, :matcher => matcher })
-      end
-
-      # Internal: Insert a matcher hash into the matchers array of the MockServer storage class.
-      #
-      def add_mock_server_matcher(matcher)
-        options = self.mock_server_options_read
-        options[:matchers].unshift(matcher)
-        mock_server_options_write(options)
-      end
+    # Internal: Register a matcher on a given route for playback
+    #
+    # method  - HTTP verb to register
+    # path    - Relative HTTP path to match
+    # matcher - Optional proc for complex matching on the request
+    #
+    # Examples
+    #
+    #    mock_server_request(:get, '/api/2/account')
+    #
+    #    mock_server_request(:get, '/api/2/account', lambda {|request, recorded_request| request.body == recorded_request.body } )
+    #
+    def mock_server_request(method, path, matcher)
+      add_mock_server_matcher({ :method => method, :path => path, :matcher => matcher })
+    end
 
-      # Internal: Fetch key from the storage class
-      #
-      def mock_server_options_fetch(key, value)
-        if self.mock_server_options_read[key]
-          mock_server_options_get(key)
-        else
-          mock_server_options_set(key, value)
-        end
-      end
+    # Internal: Insert a matcher hash into the matchers array of the MockServer storage class.
+    #
+    def add_mock_server_matcher(matcher)
+      options = self.mock_server_options_read
+      options[:matchers].unshift(matcher)
+      mock_server_options_write(options)
+    end
 
-      # Internal: Setter for the storage class
-      #
-      def mock_server_options_set(key, value)
-        hash = self.mock_server_options_read
-        hash[key] = value
-        self.mock_server_options_write(hash)
+    # Internal: Fetch key from the storage class
+    #
+    def mock_server_options_fetch(key, value)
+      if self.mock_server_options_read[key]
+        mock_server_options_get(key)
+      else
+        mock_server_options_set(key, value)
       end
+    end
 
-      # Internal: Getter for the storage class
-      #
-      def mock_server_options_get(key)
-        hash = self.mock_server_options_read
-        hash[key]
-      end
+    # Internal: Setter for the storage class
+    #
+    def mock_server_options_set(key, value)
+      hash = self.mock_server_options_read
+      hash[key] = value
+      self.mock_server_options_write(hash)
+    end
 
+    # Internal: Getter for the storage class
+    #
+    def mock_server_options_get(key)
+      hash = self.mock_server_options_read
+      hash[key]
     end
+
   end
 end

data/lib/mock_server/state.rb

@@ -1,33 +1,30 @@
 require 'hashie'
 
-module MockServer
-  class State < Hashie::Dash
-    property :path, :default => 'fixtures/records'
-    property :filename, :default => 'record'
-    property :routes, :default => []
-    property :record_filenames, :default => []
-    property :matchers, :default => []
-    property :verbose, :default => false
-    property :requests_stack, :default => []
-    property :success_stack, :default => []
-    property :errors_stack, :default => []
-    property :requests_stack, :default => []
-    property :matcher_exceptions, :default => []
+class MockServer::State < Hashie::Dash
+  property :path, :default => 'fixtures/records'
+  property :filename, :default => 'record'
+  property :routes, :default => []
+  property :record_filenames, :default => []
+  property :matchers, :default => []
+  property :verbose, :default => false
+  property :requests_stack, :default => []
+  property :success_stack, :default => []
+  property :errors_stack, :default => []
+  property :requests_stack, :default => []
+  property :matcher_exceptions, :default => []
 
-    def merge(hash)
-      new_hash = self
-      hash.each do |k,v|
-        new_hash[k] = v
-      end
-      new_hash
+  def merge(hash)
+    new_hash = self
+    hash.each do |k,v|
+      new_hash[k] = v
     end
+    new_hash
+  end
 
-    def merge!(hash)
-      hash.each do |k,v|
-        self[k] = v
-      end
-      self
+  def merge!(hash)
+    hash.each do |k,v|
+      self[k] = v
     end
-
+    self
   end
 end

data/lib/mock_server/store/global.rb

@@ -1,22 +1,18 @@
 require 'hashie'
 
-module MockServer
-  module Store
-
-      def mock_server_options_merge(opt = {})
-        $mock_server_options ||= MockServer::State.new(opt)
-        $mock_server_options.merge!(opt)
-      end
-
-      def mock_server_options_read
-        $mock_server_options ||= MockServer::State.new
-        $mock_server_options
-      end
+module MockServer::Store
+  def mock_server_options_merge(opt = {})
+    $mock_server_options ||= MockServer::State.new(opt)
+    $mock_server_options.merge!(opt)
+  end
 
-      def mock_server_options_write(value)
-        $mock_server_options ||= MockServer::State.new
-        $mock_server_options = value
-      end
+  def mock_server_options_read
+    $mock_server_options ||= MockServer::State.new
+    $mock_server_options
+  end
 
+  def mock_server_options_write(value)
+    $mock_server_options ||= MockServer::State.new
+    $mock_server_options = value
   end
 end

data/lib/mock_server/utils.rb

@@ -1,59 +1,60 @@
 require 'yaml'
 require 'json'
 
-module MockServer
-  module Utils
-
-    private
-
-    def verbose(env)
-      interception = lazy_match(@options[:routes], env["PATH_INFO"]) ? "intercepted!" : "NOT intercepted."
-      puts %([MockServer] #{env["PATH_INFO"]} was #{interception}"\n)
-    end
-
-    def lazy_match(strings, path)
-      regexps = strings.map { |str|
-        escaped = Regexp.escape(str)
-        escaped.gsub!('\\*\\*', '[\w|.|\-|\/]+')
-        escaped.gsub!('\\*', '[\w|.|\-]+')
-        Regexp.new("^#{escaped}$")
-      }
-
-      regexps.any? { |regex| regex.match(path) }
-    end
-
-    def hashified_request
-      #rewind to ensure we read from the start
-      @request.body.rewind
-
-      #read body
-      body = @request.body.read
-
-      #rewind in case upstream expects it rewound
-      @request.body.rewind
-
-      json = JSON.parse(body) rescue body
-
-      {
-        :method  => @request.request_method,
-        :path    => @request.path,
-        :query   => @request.query_string,
-        :body    => json
-      }
-    end
-  
-    def hashify_response(status, header, response)
-      {
-        :method  => @request.request_method,
-        :path    => @request.path,
-        :status  => status,
-        :headers => header,
-        :body    => if response.respond_to? :body
-          response.body
-        else
-          response.join
-        end
-      }
-    end
+module MockServer::Utils
+  private
+
+  def verbose(env)
+    interception = lazy_match(@options[:routes], env["PATH_INFO"]) ? "intercepted!" : "NOT intercepted."
+    puts %([MockServer] #{env["PATH_INFO"]} was #{interception}"\n)
+  end
+
+  def matchable_request?(env)
+    @options[:routes] and lazy_match @options[:routes], env["PATH_INFO"]
+  end
+
+  def lazy_match(strings, path)
+    regexps = strings.map { |str|
+      escaped = Regexp.escape(str)
+      escaped.gsub!('\\*\\*', '[\w|.|\-|\/]+')
+      escaped.gsub!('\\*', '[\w|.|\-]+')
+      Regexp.new("^#{escaped}$")
+    }
+
+    regexps.any? { |regex| regex.match(path) }
+  end
+
+  def hashified_request
+    #rewind to ensure we read from the start
+    @request.body.rewind
+
+    #read body
+    body = @request.body.read
+
+    #rewind in case upstream expects it rewound
+    @request.body.rewind
+
+    json = JSON.parse(body) rescue body
+
+    {
+      :method  => @request.request_method,
+      :path    => @request.path,
+      :query   => @request.query_string,
+      :body    => json
+    }
+  end
+
+  def hashify_response(status, header, response)
+    {
+      :method  => @request.request_method,
+      :path    => @request.path,
+      :status  => status,
+      :headers => header,
+      :body    => if response.respond_to? :body
+        response.body
+      else
+        response.join
+      end
+    }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mock_server
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
   prerelease: 
 platform: ruby
 authors: