rory 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 519e856afba46c0680d6d3af79ec301e16437bce
-  data.tar.gz: b6f3aff18d16be85d47eae141dd8f11f7946fcf8
+  metadata.gz: 40ba6de912d0a2eff585bacee9ac6e17583bf70c
+  data.tar.gz: de1a192df73c293d81945d0f015173c3e338484e
 SHA512:
-  metadata.gz: ea76b00f53570b120d821f2e4f356cca6531ae15f85b4fe61a41f856d3ac025773b3e326bf9eef49ff2151e7a6d91189d9c3f876f0f08b294fe6fe36ff45df98
-  data.tar.gz: eed96368cd3a1e75d274f4c0f21d55a2b51b8340c10af48c92b7694b287837ccc9119fd9b54aee8850145f8a1d635f22b8f431432a8d9b72a655af32c847beca
+  metadata.gz: 864bb31119f46b7f067df7dcb60779844b53efd383f8a40de18376054abb36263694a19b9f40fc0414fcf7ce36577a83a59d55e7f03cedf23e170309a409a2c1
+  data.tar.gz: 23e76ae90efc1de98ecd4cd629ca64624eccc09576156d7cc7a647de7ab07a05326890b9fea1b54304e81138e997c86c51e347a7613a4b8f00e578ca017a08a0

data/lib/rory.rb

@@ -1,11 +1,8 @@
 ENV['RORY_ENV'] ||= ENV['RACK_ENV'] || 'development'
 
-if ENV['RORY_STAGE']
-  raise "Use of 'RORY_STAGE' no longer supported. Use 'RORY_ENV' instead."
-end
-
 require 'yaml'
 require 'sequel'
+require 'rack/contrib'
 require 'rory/application'
 require 'rory/dispatcher'
 require 'rory/route'

data/lib/rory/application.rb

@@ -1,6 +1,9 @@
 require 'pathname'
 require 'logger'
 require 'rory/route_mapper'
+require 'rack/commonlogger'
+require_relative 'request_parameter_logger'
+
 
 module Rory
   # Main application superclass.  Applications should subclass this class,
@@ -17,9 +20,9 @@ module Rory
       private :new
       attr_reader :root
 
-      def inherited(base)
+      def inherited(subclass)
         super
-        Rory.application = base.instance
+        Rory.application = subclass.instance
       end
 
       def method_missing(*args, &block)
@@ -59,9 +62,11 @@ module Rory
     end
 
     def config_path
-      @config_path ||= begin
-        root_path.join('config')
-      end
+      @config_path ||= root_path.join('config')
+    end
+
+    def log_path
+      @log_path ||= root_path.join('log')
     end
 
     def set_routes(&block)
@@ -96,6 +101,7 @@ module Rory
     end
 
     def use_middleware(*args, &block)
+      @stack = nil
       middleware << [args, block]
     end
 
@@ -107,25 +113,44 @@ module Rory
       Rory::Dispatcher.rack_app(self)
     end
 
-    def stack
-      builder = Rack::Builder.new
-      middleware.each do |args, block|
-        builder.use *args, &block
+    def request_logging_on?
+      @request_logging != false
+    end
+
+    def turn_off_request_logging!
+      @stack = nil
+      @request_logging = false
+    end
+
+    def use_default_middleware
+      if request_logging_on?
+        use_middleware Rack::PostBodyContentTypeParser
+        use_middleware Rack::CommonLogger, logger
+        use_middleware Rory::RequestParameterLogger, logger
       end
-      builder.run dispatcher
-      builder
+    end
+
+    def stack
+      @stack ||= Rack::Builder.new.tap { |builder|
+        use_default_middleware
+        middleware.each do |args, block|
+          builder.use *args, &block
+        end
+        builder.run dispatcher
+      }
     end
 
     def call(env)
       stack.call(env)
     end
 
+    def log_file
+      Dir.mkdir(log_path) unless File.exists?(log_path)
+      File.open(log_path.join("#{ENV['RORY_ENV']}.log"), 'a').tap { |file| file.sync = true }
+    end
+
     def logger
-      @logger ||= begin
-        Dir.mkdir('log') unless File.exists?('log')
-        file = File.open(File.join('log', "#{ENV['RORY_ENV']}.log"), 'a')
-        Logger.new(file)
-      end
+      @logger ||= Logger.new(log_file)
     end
   end
 end

data/lib/rory/parameter_filter.rb

@@ -0,0 +1,64 @@
+module Rory
+  class ParameterFilter
+    FILTERED = '[FILTERED]'.freeze
+
+    def initialize(filters = [])
+      @filters = filters
+    end
+
+    def filter(params)
+      compiled_filter.call(params)
+    end
+
+    private
+
+    def compiled_filter
+      @compiled_filter ||= CompiledFilter.compile(@filters)
+    end
+
+    class CompiledFilter
+      def self.compile(filters)
+        return lambda { |params| params.dup } if filters.empty?
+
+        strings, regexps, blocks = [], [], []
+
+        filters.each do |item|
+          case item
+            when Regexp
+              regexps << item
+            else
+              strings << item.to_s
+          end
+        end
+
+        regexps << Regexp.new(strings.join('|'), true) unless strings.empty?
+        new regexps, blocks
+      end
+
+      attr_reader :regexps, :blocks
+
+      def initialize(regexps, blocks)
+        @regexps = regexps
+        @blocks  = blocks
+      end
+
+      def call(original_params)
+        filtered_params = {}
+
+        original_params.each do |key, value|
+          if regexps.any? { |r| key =~ r }
+            value = FILTERED
+          elsif value.is_a?(Hash)
+            value = call(value)
+          elsif value.is_a?(Array)
+            value = value.map { |v| v.is_a?(Hash) ? call(v) : v }
+          end
+
+          filtered_params[key] = value
+        end
+
+        filtered_params
+      end
+    end
+  end
+end

data/lib/rory/request_parameter_logger.rb

@@ -0,0 +1,58 @@
+require_relative 'parameter_filter'
+
+module Rory
+  class RequestParameterLogger
+
+    def initialize(app, logger=nil, filters=[:password])
+      @app = app
+      @logger = logger
+      @filters = filters
+    end
+
+    def call(env)
+      @env = env
+      @env['rack.input'].rewind
+      log_request
+      @app.call(@env)
+    end
+
+    private
+
+    def log_request
+      log_message(request_signature)
+      log_message("Parameters: #{filtered_params}")
+    end
+
+    def logger
+      @logger || @env['rack.errors']
+    end
+
+    def log_message(message)
+      if logger.respond_to?(:write)
+        logger.write(message + "\n")
+      else
+        logger.info(message)
+      end
+    end
+
+    def parameter_filter
+      Rory::ParameterFilter.new(@filters)
+    end
+
+    def filtered_params
+      parameter_filter.filter(unfiltered_params)
+    end
+
+    def request
+      Rack::Request.new(@env)
+    end
+
+    def unfiltered_params
+      request.params
+    end
+
+    def request_signature
+      %{Started #{@env['REQUEST_METHOD']} "#{@env['PATH_INFO']}" for #{@env['REMOTE_ADDR']} at #{Time.now}}
+    end
+  end
+end

data/lib/rory/version.rb

@@ -1,3 +1,3 @@
 module Rory
-  VERSION = '0.5.3'
+  VERSION = '0.6.0'
 end

data/rory.gemspec

@@ -28,16 +28,18 @@ EOF
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'rack', '>= 1.0'
+  s.add_runtime_dependency 'rack', '~> 1.0'
+  s.add_runtime_dependency 'rack-contrib', '~> 1.2'
   s.add_runtime_dependency 'sequel', '~> 4.0'
   s.add_runtime_dependency 'thin', '~> 1.0'
 
-  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rake', '~> 10.4'
   s.add_development_dependency 'rspec', '~> 3'
-  s.add_development_dependency 'capybara'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'reek'
-  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'capybara', '~> 2.4'
+  s.add_development_dependency 'yard', '~> 0.8'
+  s.add_development_dependency 'reek', '~> 2.2'
+  s.add_development_dependency 'simplecov', '~> 0.10'
   s.add_development_dependency 'bundler', '~> 1.0'
+  s.add_development_dependency 'pry', '~> 0.10'
 end
 

data/spec/fixture_app/config/application.rb

@@ -1,4 +1,5 @@
 module Fixture
   class Application < Rory::Application
+    turn_off_request_logging!
   end
 end

data/spec/lib/rory/application_spec.rb

@@ -1,16 +1,23 @@
 describe Rory::Application do
+  let(:subject) {
+    Class.new(Rory::Application).tap { |app|
+      app.root = "whatever"
+      app.turn_off_request_logging!
+    }
+  }
+
   describe ".configure" do
     it 'yields the given block to self' do
-      Fixture::Application.configure do |c|
-        expect(c).to eq(Fixture::Application.instance)
+      subject.configure do |c|
+        expect(c).to eq(subject.instance)
       end
     end
   end
 
   describe '.config_path' do
     it 'is set to {root}/config by default' do
-      expect(Fixture::Application.config_path).to eq(
-        Pathname.new(Fixture::Application.root).join('config')
+      expect(subject.config_path).to eq(
+        Pathname.new(subject.root).join('config')
       )
     end
 
@@ -20,64 +27,112 @@ describe Rory::Application do
       expect {
         RootlessApp.config_path
       }.to raise_error(RootlessApp::RootNotConfigured)
-      Rory.application = Fixture::Application.instance
+      Rory.application = subject.instance
+    end
+  end
+
+  describe '.log_path' do
+    it 'is set to {root}/config by default' do
+      expect(subject.log_path).to eq(
+        Pathname.new(subject.root).join('log')
+      )
+    end
+
+    it 'raises exception if root not set' do
+      Rory.application = nil
+      class RootlessApp < Rory::Application; end
+      expect {
+        RootlessApp.config_path
+      }.to raise_error(RootlessApp::RootNotConfigured)
+      Rory.application = subject.instance
     end
   end
 
   describe ".respond_to?" do
     it 'returns true if the instance said so' do
-      expect(Fixture::Application.instance).to receive(:respond_to?).with(:goat).and_return(true)
-      expect(Fixture::Application.respond_to?(:goat)).to be_truthy
+      expect(subject.instance).to receive(:respond_to?).with(:goat).and_return(true)
+      expect(subject.respond_to?(:goat)).to be_truthy
     end
 
     it 'does the usual thing if instance says no' do
-      expect(Fixture::Application.instance).to receive(:respond_to?).twice.and_return(false)
-      expect(Fixture::Application.respond_to?(:to_s)).to be_truthy
-      expect(Fixture::Application.respond_to?(:obviously_not_a_real_method)).to be_falsey
+      expect(subject.instance).to receive(:respond_to?).twice.and_return(false)
+      expect(subject.respond_to?(:to_s)).to be_truthy
+      expect(subject.respond_to?(:obviously_not_a_real_method)).to be_falsey
     end
   end
 
   describe ".call" do
     it "forwards arg to new dispatcher, and calls dispatch" do
       dispatcher = double(:dispatch => :expected)
-      rack_request = double
-      allow(Rack::Request).to receive(:new).with(:env).and_return(rack_request)
-      expect(Rory::Dispatcher).to receive(:new).with(rack_request, Fixture::Application.instance).and_return(dispatcher)
-      expect(Fixture::Application.call(:env)).to eq(:expected)
+      rack_request = double(:media_type => 'application/json')
+      env = { "rack.input" => double(:read => {}) }
+      allow(Rack::Request).to receive(:new).with(env).and_return(rack_request)
+      expect(Rory::Dispatcher).to receive(:new).with(rack_request, subject.instance).and_return(dispatcher)
+      expect(subject.call(env)).to eq(:expected)
+    end
+  end
+
+  describe ".log_file" do
+    it "creates the log file directory if it does not exist" do
+      file = double(:sync= => true)
+      allow(File).to receive(:exists?).and_return(false)
+      allow(Dir).to receive(:mkdir).and_return(true)
+      allow(File).to receive(:open).and_return(file)
+      expect(subject.log_file).to eq(file)
+    end
+
+    it "returns the file and does not create the log file directory if it does not exist" do
+      file = double(:sync= => true)
+      allow(File).to receive(:exists?).and_return(true)
+      allow(File).to receive(:open).and_return(file)
+      expect(subject.log_file).to eq(file)
+    end
+  end
+
+  describe ".logger" do
+    it "reutrns a logger" do
+      logger = double
+      allow_any_instance_of(subject).to receive(:log_file)
+      allow(Logger).to receive(:new).and_return(logger)
+      expect(subject.logger).to eq(logger)
+    end
+  end
+
+  describe ".use_default_middleware" do
+    it "adds middleware when request logging is on" do
+      allow(subject.instance).to receive(:request_logging_on?).and_return(true)
+      allow(subject.instance).to receive(:logger).and_return(:the_logger)
+      subject.use_default_middleware
+      expect(subject.middleware.count).to_not eq(0)
+    end
+
+    it "does not add middleware when request logging is off" do
+      allow(subject.instance).to receive(:request_logging_on?).and_return(false)
+      allow(subject.instance).to receive(:logger).and_return(:the_logger)
+      subject.use_default_middleware
+      expect(subject.middleware.count).to eq(0)
     end
   end
 
   describe ".load_config_data" do
     it "returns parsed yaml file with given name from directory at config_path" do
-      allow_any_instance_of(Fixture::Application).to receive(:config_path).and_return('Africa the Great')
+      allow_any_instance_of(subject).to receive(:config_path).and_return('Africa the Great')
       allow(YAML).to receive(:load_file).with(
         File.expand_path(File.join('Africa the Great', 'foo_type.yml'))).
         and_return(:oscar_the_grouch_takes_a_nap)
-      expect(Fixture::Application.load_config_data(:foo_type)).to eq(:oscar_the_grouch_takes_a_nap)
+      expect(subject.load_config_data(:foo_type)).to eq(:oscar_the_grouch_takes_a_nap)
     end
   end
 
   describe ".connect_db" do
     it "sets up sequel connection to DB from YAML file" do
       config = { 'development' => :expected }
-      allow_any_instance_of(Fixture::Application).to receive(:load_config_data).with(:database).and_return(config)
-      expect(Sequel).to receive(:connect).with(:expected).and_return(double(:loggers => []))
-      Fixture::Application.connect_db('development')
-    end
-  end
-
-  describe ".routes" do
-    it "generates a collection of routing objects from route configuration" do
-      expect(Fixture::Application.routes).to eq [
-        Rory::Route.new('foo/:id/bar', :to => 'foo#bar', :methods => [:get, :post]),
-        Rory::Route.new('this/:path/is/:very_awesome', :to => 'awesome#rad'),
-        Rory::Route.new('lumpies/:lump', :to => 'lumpies#show', :methods => [:get], :module => 'goose'),
-        Rory::Route.new('rabbits/:chew', :to => 'rabbits#chew', :methods => [:get], :module => 'goose/wombat'),
-        Rory::Route.new('', :to => 'root#vegetable', :methods => [:get]),
-        Rory::Route.new('', :to => 'root#no_vegetable', :methods => [:delete]),
-        Rory::Route.new('for_reals/switching', :to => 'for_reals#switching', :methods => [:get]),
-        Rory::Route.new('for_reals/:parbles', :to => 'for_reals#srsly', :methods => [:get])
-      ]
+      logger_array = []
+      allow(subject.instance).to receive(:logger).and_return(:the_logger)
+      allow(subject.instance).to receive(:load_config_data).with(:database).and_return(config)
+      expect(Sequel).to receive(:connect).with(:expected).and_return(double(:loggers => logger_array))
+      subject.connect_db('development')
+      expect(logger_array).to match_array([:the_logger])
     end
   end
 
@@ -90,43 +145,61 @@ describe Rory::Application do
 
   describe '.auto_require_paths' do
     after(:each) do
-      Fixture::Application.instance.instance_variable_set(:@auto_require_paths, nil)
+      subject.instance.instance_variable_set(:@auto_require_paths, nil)
     end
 
     it 'includes models, controllers, and helpers by default' do
-      expect(Fixture::Application.auto_require_paths).to eq(['models', 'controllers', 'helpers'])
+      expect(subject.auto_require_paths).to eq(['models', 'controllers', 'helpers'])
     end
 
     it 'accepts new paths' do
-      Fixture::Application.auto_require_paths << 'chocolates'
-      expect(Fixture::Application.auto_require_paths).to eq(['models', 'controllers', 'helpers', 'chocolates'])
+      subject.auto_require_paths << 'chocolates'
+      expect(subject.auto_require_paths).to eq(['models', 'controllers', 'helpers', 'chocolates'])
     end
   end
 
   describe '.require_all_files' do
     it 'requires all files in auto_require_paths' do
-      allow_any_instance_of(Fixture::Application).to receive(:auto_require_paths).and_return(['goats', 'rhubarbs'])
+      allow_any_instance_of(subject).to receive(:auto_require_paths).and_return(['goats', 'rhubarbs'])
       [:goats, :rhubarbs].each do |folder|
         expect(Rory::Support).to receive(:require_all_files_in_directory).
-          with(Pathname.new(Fixture::Application.root).join("#{folder}"))
+          with(Pathname.new(subject.root).join("#{folder}"))
       end
-      Fixture::Application.require_all_files
+      subject.require_all_files
     end
   end
 
   describe '.use_middleware' do
     it 'adds the given middleware to the stack, retaining args and block' do
-      require Fixture::Application.root.join('lib', 'dummy_middleware')
-      Fixture::Application.use_middleware DummyMiddleware, :puppy do |dm|
+      require_relative '../../fixture_app/lib/dummy_middleware'
+      subject.use_middleware DummyMiddleware, :puppy do |dm|
         dm.prefix = 'a salubrious'
       end
 
-      expect(Fixture::Application.instance).to receive(:dispatcher).
+      expect(subject.instance).to receive(:dispatcher).
         and_return(dispatch_stack_mock = double)
       expect(dispatch_stack_mock).to receive(:call).
         with('a salubrious puppy')
-      Fixture::Application.call({})
-      Fixture::Application.middleware.clear
+      subject.call({})
+      subject.middleware.clear
+    end
+  end
+
+  context "with fixture application" do
+    subject { Fixture::Application }
+    describe ".routes" do
+      it "generates a collection of routing objects from route configuration" do
+        expect(subject.routes).to eq [
+          Rory::Route.new('foo/:id/bar', :to => 'foo#bar', :methods => [:get, :post]),
+          Rory::Route.new('this/:path/is/:very_awesome', :to => 'awesome#rad'),
+          Rory::Route.new('lumpies/:lump', :to => 'lumpies#show', :methods => [:get], :module => 'goose'),
+          Rory::Route.new('rabbits/:chew', :to => 'rabbits#chew', :methods => [:get], :module => 'goose/wombat'),
+          Rory::Route.new('', :to => 'root#vegetable', :methods => [:get]),
+          Rory::Route.new('', :to => 'root#no_vegetable', :methods => [:delete]),
+          Rory::Route.new('for_reals/switching', :to => 'for_reals#switching', :methods => [:get]),
+          Rory::Route.new('for_reals/:parbles', :to => 'for_reals#srsly', :methods => [:get])
+        ]
+      end
     end
   end
-end
+end

data/spec/lib/rory/controller_spec.rb

@@ -215,7 +215,7 @@ describe Rory::Controller do
 
   describe "#generate_body_from_template" do
     it "returns rendered template with given name" do
-      expect(subject.generate_body_from_template('test/letsgo')).to eq("Let's go content")
+      expect(subject.generate_body_from_template('test/letsgo', :app => Fixture::Application)).to eq("Let's go content")
     end
 
     it "returns renderer output" do

data/spec/lib/rory/parameter_filter_spec.rb

@@ -0,0 +1,50 @@
+describe Rory::ParameterFilter do
+
+  describe '#initialize' do
+    it 'sets the filters' do
+      expect(subject.instance_variable_get(:@filters)).to eq []
+    end
+  end
+
+  describe '#filter' do
+    it 'returns params unchanged' do
+      unfiltered_params = {"address"=>"11802 MCDONALD ST, Los Angeles, CA 90230",
+                "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"000-02-9999"}],
+                "overrides"=>{"ofac_7403"=>"clear"}}
+
+      expect(subject.filter(unfiltered_params)).to eq unfiltered_params
+    end
+
+    it 'returns params filtered by' do
+      subject = described_class.new([:ssn])
+      unfiltered_params = {"address"=>"11802 MCDONALD ST, Los Angeles, CA 90230",
+                "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"000-02-9999"}],
+                "overrides"=>{"ofac_7403"=>"clear"}}
+
+      filtered_params = {"address"=>"11802 MCDONALD ST, Los Angeles, CA 90230",
+                           "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"[FILTERED]"}],
+                           "overrides"=>{"ofac_7403"=>"clear"}}
+
+
+      expect(subject.filter(unfiltered_params)).to eq filtered_params
+    end
+
+    it 'filters based upon regex' do
+
+      filter_words = []
+      filter_words << /ofac*/
+
+      subject = described_class.new(filter_words)
+
+      unfiltered_params = {:address=>"11802 MCDONALD ST, Los Angeles, CA 90230",
+                           "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"000-02-9999"}],
+                           "overrides"=>{"ofac_7403"=>"clear"}}
+
+      filtered_params = {:address=>"11802 MCDONALD ST, Los Angeles, CA 90230",
+                           "owners"=>[{"first_name"=>"GOLD", "last_name"=>"PATH", "ssn"=>"000-02-9999"}],
+                           "overrides"=>{"ofac_7403"=>"[FILTERED]"}}
+
+      expect(subject.filter(unfiltered_params)).to eq filtered_params
+    end
+  end
+end

data/spec/lib/rory/renderer_spec.rb

@@ -1,34 +1,36 @@
-describe Rory::Renderer do  
+describe Rory::Renderer do
   describe "#render" do
+    let(:app) { Fixture::Application }
+
     it "returns text of template" do
-      renderer = Rory::Renderer.new('test/static')
+      renderer = Rory::Renderer.new('test/static', :app => app)
       expect(renderer.render).to eq('Static content')
     end
 
     it "returns text of template in given layout" do
-      controller = Rory::Renderer.new('test/static', :layout => 'surround')
+      controller = Rory::Renderer.new('test/static', :layout => 'surround', :app => app)
       expect(controller.render).to eq('Surrounding Static content is fun')
     end
 
     it "handles symbolized layout name" do
-      controller = Rory::Renderer.new('test/static', :layout => :surround)
+      controller = Rory::Renderer.new('test/static', :layout => :surround, :app => app)
       expect(controller.render).to eq('Surrounding Static content is fun')
     end
 
     it "exposes locals to template" do
-      controller = Rory::Renderer.new('test/dynamic', :locals => { :word => 'hockey' })
+      controller = Rory::Renderer.new('test/dynamic', :locals => { :word => 'hockey' }, :app => app)
       expect(controller.render).to eq('Word: hockey')
     end
 
     it "can render nested templates" do
-      controller = Rory::Renderer.new('test/double_nested', :locals => { :word => 'hockey' })
+      controller = Rory::Renderer.new('test/double_nested', :locals => { :word => 'hockey' }, :app => app)
       expect(controller.render).to eq( 
         "Don't Say A Bad Word: Poop!"
       )
     end
 
     it "exposes base_path to template" do
-      controller = Rory::Renderer.new('test/a_link', :base_path => 'spoo')
+      controller = Rory::Renderer.new('test/a_link', :base_path => 'spoo', :app => app)
       expect(controller.render).to eq('You came from spoo.')
     end
   end
@@ -41,8 +43,8 @@ describe Rory::Renderer do
     end
 
     it 'uses Rory.root if no app specified' do
-      renderer = Rory::Renderer.new('goose')
-      expect(renderer.view_path).to eq(File.join(Rory.root, 'views', 'goose.html.erb'))
+      renderer = Rory::Renderer.new('goose', :app => double(:root => "horse"))
+      expect(renderer.view_path).to eq(File.expand_path(File.join('views', 'goose.html.erb'), "horse"))
     end
   end
 end

data/spec/lib/rory/request_parameter_logger_spec.rb

@@ -0,0 +1,95 @@
+describe Rory::RequestParameterLogger do
+
+  let(:logger) { double(:write) }
+  let(:app) { double(:call) }
+  subject { described_class.new(app, logger, :filters) }
+
+  describe '#initialize' do
+    it 'returns a new RequestParameterLogger' do
+      expect(subject).to be_an_instance_of(Rory::RequestParameterLogger)
+    end
+
+    it 'returns a new RequestParameterLogger with parameters' do
+      expect(subject.instance_variable_get(:@app)).to eq(app)
+      expect(subject.instance_variable_get(:@logger)).to eq(logger)
+      expect(subject.instance_variable_get(:@filters)).to eq(:filters)
+    end
+  end
+
+  describe '#log_request' do
+
+    context 'when logger responds to write' do
+      it 'writes the request to the logger' do
+        allow(subject).to receive(:request_signature).and_return('request_signature')
+        allow(subject).to receive(:filtered_params).and_return('filtered_params')
+        expect(logger).to receive(:write).exactly(2).times
+        subject.send(:log_request)
+      end
+    end
+
+    context 'when logger does not respond to write' do
+      let(:logger) { double(:info) }
+      it 'writes the request to the logger' do
+        allow(subject).to receive(:request_signature).and_return('request_signature')
+        allow(subject).to receive(:filtered_params).and_return('filtered_params')
+        expect(logger).to receive(:info).exactly(2).times
+        subject.send(:log_request)
+      end
+    end
+  end
+
+  describe '#logger' do
+    it 'returns @logger' do
+      expect(subject.send(:logger)).to eq(logger)
+    end
+
+    it 'returns rack.errors ' do
+      subject = described_class.new(:app)
+      subject.instance_variable_set(:@env, {'rack.errors' => 'cocoa'})
+      expect(subject.send(:logger)).to eq('cocoa')
+    end
+  end
+
+  describe '#filtered_params' do
+    it 'filters the params' do
+      expect(Rory::ParameterFilter).to receive(:new).and_return(double(:filter => nil))
+      expect(subject).to receive(:unfiltered_params)
+      subject.send(:filtered_params)
+    end
+  end
+
+  describe '#unfiltered_params' do
+    it 'returns unfiltered params' do
+      expect(Rack::Request).to receive(:new).and_return(double(:params => nil))
+      subject.send(:unfiltered_params)
+    end
+  end
+
+  describe '#request_signature' do
+    it 'returns a request signature formatted string' do
+      env = {
+        'REQUEST_METHOD' => "POST",
+        'PATH_INFO' => "/mushy_mushy",
+        'REMOTE_ADDR' => "127.0.0.1"
+      }
+
+      allow(Time).to receive(:now).and_return("2015-06-08 15:16:42 -0700")
+      subject.instance_variable_set(:@env, env)
+      expect(subject.send(:request_signature)).to eq('Started POST "/mushy_mushy" for 127.0.0.1 at 2015-06-08 15:16:42 -0700')
+    end
+  end
+
+
+  describe '#call' do
+    it 'writes the request and parameters to the log file' do
+      env = {
+        'rack.input' => double(:rewind => nil)
+      }
+      expect(app).to receive(:call).with(env)
+      expect(subject).to receive(:log_request)
+
+      subject.call(env)
+      expect(subject.instance_variable_get(:@env)).to eq(env)
+    end
+  end
+end

data/spec/lib/rory_spec.rb

@@ -1,13 +1,15 @@
 describe Rory do
+  let!(:new_app) { Class.new(Rory::Application) }
+
   describe '.application' do
     it 'is by default set to the Rory::Application instance' do
-      expect(Rory.application).to eq(Fixture::Application.instance)
+      expect(Rory.application).to eq(new_app.instance)
     end
   end
 
   describe '.root' do
     it 'returns root of application' do
-      expect(Rory.root).to eq(Rory.application.root)
+      expect(Rory.root).to eq(new_app.root)
     end
   end
 end

data/spec/spec_helper.rb

@@ -20,5 +20,5 @@ Fixture::Application.require_all_files
 Capybara.app = Fixture::Application
 
 RSpec.configure do |config|
-
+  config.order = "random"
 end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rory
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Ravi Gadad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-09 00:00:00.000000000 Z
+date: 2015-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rack-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +70,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -84,58 +98,58 @@ dependencies:
   name: capybara
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: reek
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
 description: |
   An exercise: Untangle the collusion of Rails idioms
   from my Ruby knowledge, while trying to understand some
@@ -171,9 +199,11 @@ files:
 - lib/rory/application.rb
 - lib/rory/controller.rb
 - lib/rory/dispatcher.rb
+- lib/rory/parameter_filter.rb
 - lib/rory/path_generation.rb
 - lib/rory/renderer.rb
 - lib/rory/renderer/context.rb
+- lib/rory/request_parameter_logger.rb
 - lib/rory/route.rb
 - lib/rory/route_mapper.rb
 - lib/rory/support.rb
@@ -191,6 +221,7 @@ files:
 - spec/fixture_app/controllers/goose/wombat/rabbits_controller.rb
 - spec/fixture_app/controllers/stub_controller.rb
 - spec/fixture_app/lib/dummy_middleware.rb
+- spec/fixture_app/log/test.log
 - spec/fixture_app/views/for_reals/but_wait.html.erb
 - spec/fixture_app/views/for_reals/custom.html.erb
 - spec/fixture_app/views/for_reals/srsly.html.erb
@@ -204,8 +235,10 @@ files:
 - spec/lib/rory/application_spec.rb
 - spec/lib/rory/controller_spec.rb
 - spec/lib/rory/dispatcher_spec.rb
+- spec/lib/rory/parameter_filter_spec.rb
 - spec/lib/rory/renderer/context_spec.rb
 - spec/lib/rory/renderer_spec.rb
+- spec/lib/rory/request_parameter_logger_spec.rb
 - spec/lib/rory/route_spec.rb
 - spec/lib/rory/support_spec.rb
 - spec/lib/rory_spec.rb