tdiary 5.4.0 → 5.5.0.beta1

data/lib/tdiary/application.rb

@@ -1,18 +1,9 @@
+require 'stringio'
 require 'tdiary'
 require 'tdiary/extensions/core'
 require 'rack/builder'
 require 'tdiary/rack'
 
-# FIXME too dirty hack :-<
-class CGI
-	def env_table_rack
-		$RACK_ENV || ENV
-	end
-
-	alias :env_table_orig :env_table
-	alias :env_table :env_table_rack
-end
-
 module TDiary
 	class Application
 		def initialize( base_dir = nil )
@@ -87,13 +78,21 @@ module TDiary
 
 	private
 		def run_plugin_startup_procs
-			# avoid offline mode at CGI.new
-			ARGV.replace([""])
-			cgi = RackCGI.new
-
-			request = TDiary::Request.new(ENV, cgi)
-			conf = TDiary::Configuration.new(cgi, request)
-			tdiary = TDiary::TDiaryBase.new(cgi, '', conf)
+			# minimal Rack env for the request handed to startup plugins
+			env = {
+				'REQUEST_METHOD'  => 'GET',
+				'SCRIPT_NAME'     => '',
+				'PATH_INFO'       => '/',
+				'QUERY_STRING'    => '',
+				'SERVER_NAME'     => 'localhost',
+				'SERVER_PORT'     => '80',
+				'rack.url_scheme' => 'http',
+				'rack.input'      => StringIO.new('')
+			}
+			request = TDiary::Request.new(env)
+			cgi = request.cgi_compat
+			conf = TDiary::Configuration.new(request)
+			tdiary = TDiary::TDiaryBase.new(request, '', conf)
 			io = conf.io_class.new(tdiary)
 
 			begin
@@ -102,6 +101,7 @@ module TDiary
 					'mode' => 'startup',
 					'diaries' => tdiary.diaries,
 					'cgi' => cgi,
+					'request' => request,
 					'years' => nil,
 					'cache_path' => io.cache_path,
 					'date' => Time.now,

data/lib/tdiary/author_only_base.rb

@@ -8,12 +8,12 @@ module TDiary
 
 		def initialize( cgi, rhtml, conf )
 			super
-			csrf_check( cgi, conf )
+			csrf_check( @request, conf )
 		end
 
 	private
 
-		def csrf_check( cgi, conf )
+		def csrf_check( request, conf )
 			# CSRF condition check
 			protection_method = conf.options['csrf_protection_method']
 			masterkey = conf.options['csrf_protection_key']
@@ -36,7 +36,7 @@ module TDiary
 				@csrf_protection="<!-- no CSRF protection key used -->"
 			end
 
-			referer = cgi.referer || ''
+			referer = request.referer || ''
 			referer = referer.sub(/\?.*$/, '')
 			base_uri = URI.parse(base_url)
 			config_uri = URI.parse(base_url) + conf.update
@@ -45,17 +45,10 @@ module TDiary
 			referer_uri = URI.parse(referer) if !referer_is_empty
 			referer_is_config = !referer_is_empty && config_uri == referer_uri
 			referer_is_config ||= Regexp.new(updaterb_regexp) =~ referer if !referer_is_empty && updaterb_regexp != ''
-			is_post = cgi.request_method == 'POST'
+			is_post = request.post?
 
-			given_key = nil
-			if cgi.valid?('csrf_protection_key')
-				given_key = cgi.params['csrf_protection_key'][0]
-				case given_key
-				when String
-				else
-					given_key = given_key.read
-				end
-			end
+			given_key = request.params['csrf_protection_key']
+			given_key = nil if given_key == ''
 
 			is_key_ok = masterkey != '' && given_key == masterkey
 

data/lib/tdiary/base.rb

@@ -13,11 +13,14 @@ module TDiary
 		DIRTY_REFERER = 4
 
 		attr_reader :cookies, :date, :diaries
-		attr_reader :cgi, :rhtml, :conf
+		attr_reader :request, :cgi, :rhtml, :conf
 		attr_reader :ignore_parser_cache
 
-		def initialize( cgi, rhtml, conf )
-			@cgi, @rhtml, @conf = cgi, rhtml, conf
+		def initialize( request, rhtml, conf )
+			@request = request
+			# plugins read the request through the @cgi facade
+			@cgi = request.cgi_compat
+			@rhtml, @conf = rhtml, conf
 			@diaries = {}
 			@cookies = []
 			@io = @conf.io_class.new( self )
@@ -86,22 +89,55 @@ module TDiary
 				@plugin.last_modified = last_modified
 				@plugin.comment = @comment
 				@plugin
+			elsif (cached = reusable_cached_plugin)
+				# reuse a plugin instance loaded by a previous request, skipping
+				# the file read + instance_eval of every plugin file.
+				@plugin = cached.prepare_for_reuse( plugin_params )
 			else
-				@plugin = Plugin::new(
-					'conf' => @conf,
-					'mode' => mode,
-					'diaries' => @diaries,
-					'cgi' => @cgi,
-					'years' => @years,
-					'cache_path' => @io.cache_path,
-					'date' => @date,
-					'comment' => @comment,
-					'last_modified' => last_modified,
-					'logger' => TDiary.logger
-				)
+				@plugin = Plugin::new( plugin_params )
+				if plugin_cache_enabled? and not @plugin.respond_to?( 'blog_category' )
+					Plugin.cache_store( plugin_cache_key, @plugin )
+				end
+				@plugin
 			end
 		end
 
+		# read-only views whose plugins do no request-specific work at load time,
+		# so a loaded instance is safe to reuse across requests.
+		PLUGIN_CACHEABLE_MODES = %w[latest day month nyear].freeze
+
+		def plugin_cache_enabled?
+			@conf.options['plugin.cache'] && PLUGIN_CACHEABLE_MODES.include?( mode )
+		end
+
+		def plugin_cache_key
+			[mode, @conf.data_path]
+		end
+
+		def reusable_cached_plugin
+			return nil unless plugin_cache_enabled?
+			cached = Plugin.cache_fetch( plugin_cache_key )
+			return nil unless cached
+			return nil if cached.respond_to?( 'blog_category' )
+			cached
+		end
+
+		def plugin_params
+			{
+				'conf' => @conf,
+				'mode' => mode,
+				'diaries' => @diaries,
+				'cgi' => @cgi,
+				'request' => @request,
+				'years' => @years,
+				'cache_path' => @io.cache_path,
+				'date' => @date,
+				'comment' => @comment,
+				'last_modified' => last_modified,
+				'logger' => TDiary.logger
+			}
+		end
+
 		def <<( diary )
 			@diaries[diary.date.strftime( '%Y%m%d' )] = diary
 		end
@@ -167,7 +203,7 @@ module TDiary
 		def initialize(cgi, rhtml, conf)
 			super
 
-			tdiary = tdiary_class(cgi.params['date'][0] || '').new(cgi, '', conf)
+			tdiary = tdiary_class(@cgi.params['date'][0] || '').new(@request, '', conf)
 			@date = tdiary.date
 			@diaries = tdiary.diaries
 			@last_modified = Time.now

data/lib/tdiary/cgi_adapter.rb

@@ -0,0 +1,86 @@
+require 'stringio'
+
+module TDiary
+	#
+	# class CGIAdapter
+	#  bridges CGI/FastCGI hosted requests to the Rack interface: builds a
+	#  Rack env from a request and writes the Rack response triplet back to
+	#  it. The request is duck-typed (env/in/out/err/finish) so that this
+	#  file works without the fcgi gem.
+	#
+	class CGIAdapter
+		# a plain CGI process serves exactly one request through ENV and
+		# the standard streams
+		PlainCGIRequest = Struct.new( :env, :in, :out, :err ) do
+			def finish; end
+		end
+
+		class << self
+			def run_cgi( dispatcher )
+				$stdin.binmode
+				run( PlainCGIRequest.new( ENV.to_hash, $stdin, $stdout, $stderr ), dispatcher )
+			end
+
+			def run( request, dispatcher )
+				env = build_env( request.env.to_hash, request.in, request.err )
+				write_response( request.out, *dispatcher.call( env ) )
+			rescue Exception => e
+				write_error( request.out, e )
+			ensure
+				request.finish
+			end
+
+			def build_env( fcgi_env, input, errors )
+				env = fcgi_env.to_hash.dup
+				env.delete( 'HTTP_CONTENT_LENGTH' )
+				env['SCRIPT_NAME'] = '' if env['SCRIPT_NAME'] == '/'
+				env['QUERY_STRING'] ||= ''
+				env['rack.input'] = StringIO.new( (input.read || '').b )
+				env['rack.errors'] = errors
+				env['rack.url_scheme'] = url_scheme( env )
+				# tell Request#cgi_compat that js/theme are served statically
+				# by the web server, not by the Rack app
+				env['tdiary.static_assets'] = true
+				env
+			end
+
+			def write_response( out, status, headers, body )
+				out.print "Status: #{status}\r\n"
+				headers.each do |key, value|
+					Array( value ).each do |v|
+						v.to_s.split( "\n" ).each do |line|
+							out.print "#{key}: #{line}\r\n"
+						end
+					end
+				end
+				out.print "\r\n"
+				body.each {|part| out.print part }
+			ensure
+				body.close if body.respond_to?( :close )
+			end
+
+		private
+
+			def url_scheme( env )
+				if %w(yes on 1).include?( env['HTTPS'].to_s.downcase ) || env['HTTP_X_FORWARDED_PROTO'] == 'https'
+					'https'
+				else
+					'http'
+				end
+			end
+
+			def write_error( out, e )
+				body = "<h1>500 Internal Server Error</h1>\n<pre>#{CGI::escapeHTML( "#{e} (#{e.class})\n\n#{e.backtrace.join( "\n" )}" )}</pre>\n"
+				write_response( out, 500, { 'content-type' => 'text/html' }, [body] )
+			end
+		end
+	end
+end
+
+# Local Variables:
+# mode: ruby
+# indent-tabs-mode: t
+# tab-width: 3
+# ruby-indent-level: 3
+# End:
+# vim: ts=3

data/lib/tdiary/cgi_compat.rb

@@ -0,0 +1,189 @@
+module TDiary
+	#
+	# class CGICompat
+	#  provides the CGI compatible interface consumed by plugins as @cgi on
+	#  top of TDiary::Request. Behaviour is locked by the shared examples in
+	#  spec/support/cgi_compat_shared_examples.rb, which are also applied to
+	#  RackCGI, the subclass the dispatcher hands to plugins on the Rack path.
+	#
+	class CGICompat
+		include TDiary::RequestExtension
+
+		attr_reader :request
+
+		def initialize( request )
+			@request = request
+			# built eagerly so that a clone (Object#clone copies instance
+			# variables by reference) shares the same params Hash, like a
+			# cloned CGI instance does. Plugins may still rely on this.
+			@params = build_params
+		end
+
+		attr_reader :params
+
+		def valid?( param, idx = 0 )
+			params[param] and params[param][idx] and params[param][idx].length > 0
+		end
+
+		def cookies
+			# CGI::Cookie keeps the multi-value cookie behaviour (00default.rb
+			# reads name and mail from the two values of the tdiary cookie)
+			@cookies ||= CGI::Cookie.parse( env_table['HTTP_COOKIE'] )
+		end
+
+		def env_table
+			@request.env
+		end
+
+		def referer
+			env_table['HTTP_REFERER']
+		end
+
+		def user_agent
+			env_table['HTTP_USER_AGENT']
+		end
+
+		def remote_addr
+			env_table['REMOTE_ADDR']
+		end
+
+		def request_method
+			env_table['REQUEST_METHOD']
+		end
+
+		def script_name
+			env_table['SCRIPT_NAME']
+		end
+
+		def remote_user
+			env_table['REMOTE_USER']
+		end
+
+		def auth_type
+			env_table['AUTH_TYPE']
+		end
+
+		def gateway_interface
+			env_table['GATEWAY_INTERFACE']
+		end
+
+		def server_name
+			env_table['SERVER_NAME']
+		end
+
+		def server_port
+			env_table['SERVER_PORT'].to_i
+		end
+
+		# the URL helpers below come from the CGI patches that used to live
+		# in core_ext.rb
+		def https?
+			return true if env_table['HTTP_X_FORWARDED_PROTO'] == 'https'
+			return false if env_table['HTTPS'].nil? or /off/i =~ env_table['HTTPS'] or env_table['HTTPS'] == ''
+			true
+		end
+
+		def request_uri
+			_request_uri = env_table['REQUEST_URI']
+			_script_name = env_table['SCRIPT_NAME']
+			if !_request_uri || _request_uri == '' || _request_uri == _script_name then
+				_path_info    = env_table['PATH_INFO'] || ''
+				_query_string = env_table['QUERY_STRING'] || ''
+				# Workaround for IIS-style PATH_INFO ('/dir/script.cgi/path', not '/path')
+				# See http://support.microsoft.com/kb/184320/
+				_request_uri = _path_info.include?(_script_name) ? '' : _script_name.dup
+				_request_uri << _path_info
+				_request_uri << '?' + _query_string if _query_string != ''
+			end
+			_request_uri
+		end
+
+		def redirect_url
+			env_table['REDIRECT_URL']
+		end
+
+		def base_url
+			return '' unless script_name
+			begin
+				script_dirname = script_name.empty? ? '' : File::dirname(script_name)
+				if https?
+					port = (server_port == 443) ? '' : ':' + server_port.to_s
+					"https://#{server_name}#{port}#{script_dirname}/"
+				else
+					port = (server_port == 80) ? '' : ':' + server_port.to_s
+					"http://#{server_name}#{port}#{script_dirname}/"
+				end.sub(%r|/+$|, '/')
+			rescue SecurityError
+				''
+			end
+		end
+
+	private
+
+		def build_params
+			source =
+				if request_method == 'POST'
+					if %r|\Amultipart/form-data|.match?( env_table['CONTENT_TYPE'].to_s )
+						@request.POST
+					else
+						# Rack's nested query parser behind request.POST keeps only
+						# the last of duplicated keys; CGI collects all of them
+						::Rack::Utils.parse_query( read_raw_body )
+					end
+				else
+					::Rack::Utils.parse_query( env_table['QUERY_STRING'].to_s )
+				end
+
+			params = {}
+			source.each do |key, value|
+				values = value.kind_of?( Array ) ? value : [value]
+				params[key] = values.map {|v| normalize_value( v ) }
+			end
+			params.default = []
+			params
+		end
+
+		def read_raw_body
+			input = env_table['rack.input']
+			return '' unless input
+			# Rack::Request#POST leaves rack.input at EOF, so rewind first in
+			# case the request params were already parsed
+			input.rewind if input.respond_to?( :rewind )
+			body = input.read
+			input.rewind if input.respond_to?( :rewind )
+			body || ''
+		end
+
+		def normalize_value( value )
+			if value.kind_of?( Hash ) and value[:tempfile]
+				# Rack multipart file upload: expose an object responding to
+				# read, which is all the consumers use
+				value[:tempfile]
+			else
+				repair_encoding( value.to_s )
+			end
+		end
+
+		# CGI/FCGI hosting retries broken UTF-8 input as Shift_JIS (index.rb,
+		# misc/lib/fcgi_patch.rb). The facade implements the same fallback on
+		# each value: invalid UTF-8 is converted from Shift_JIS when possible,
+		# otherwise scrubbed.
+		def repair_encoding( str )
+			str = str.dup.force_encoding( Encoding::UTF_8 ) unless str.encoding == Encoding::UTF_8
+			return str if str.valid_encoding?
+			begin
+				str.dup.force_encoding( Encoding::Shift_JIS ).encode( Encoding::UTF_8 )
+			rescue EncodingError
+				str.scrub
+			end
+		end
+	end
+end
+
+# Local Variables:
+# mode: ruby
+# indent-tabs-mode: t
+# tab-width: 3
+# ruby-indent-level: 3
+# End:
+# vim: ts=3

data/lib/tdiary/configuration.rb

@@ -6,7 +6,7 @@ module TDiary
 	class Configuration
 		attr_reader :database_url
 
-		def initialize( cgi = nil, request = nil )
+		def initialize( request = nil )
 			@request = request
 			configure_attrs
 			configure_bot_pattern

data/lib/tdiary/core_ext.rb

@@ -51,60 +51,11 @@ class String
 	end
 end
 
-=begin
-== CGI class
-enhanced CGI class
-=end
-class CGI
-	include TDiary::RequestExtension
-
-	def valid?( param, idx = 0 )
-		self.params[param] and self.params[param][idx] and self.params[param][idx].length > 0
-	end
-
-	def https?
-		return true if env_table['HTTP_X_FORWARDED_PROTO'] == 'https'
-		return false if env_table['HTTPS'].nil? or /off/i =~ env_table['HTTPS'] or env_table['HTTPS'] == ''
-		true
-	end
-
-	def request_uri
-		_request_uri = env_table['REQUEST_URI']
-		_script_name = env_table['SCRIPT_NAME']
-		if !_request_uri || _request_uri == '' || _request_uri == _script_name then
-			_path_info    = env_table['PATH_INFO'] || ''
-			_query_string = env_table['QUERY_STRING'] || ''
-			# Workaround for IIS-style PATH_INFO ('/dir/script.cgi/path', not '/path')
-			# See http://support.microsoft.com/kb/184320/
-			_request_uri = _path_info.include?(_script_name) ? '' : _script_name.dup
-			_request_uri << _path_info
-			_request_uri << '?' + _query_string if _query_string != ''
-		end
-		_request_uri
-	end
-
-	def redirect_url
-		env_table['REDIRECT_URL']
-	end
-
-	def base_url
-		return '' unless script_name
-		begin
-			script_dirname = script_name.empty? ? '' : File::dirname(script_name)
-			if https?
-				port = (server_port == 443) ? '' : ':' + server_port.to_s
-				"https://#{server_name}#{port}#{script_dirname}/"
-			else
-				port = (server_port == 80) ? '' : ':' + server_port.to_s
-				"http://#{server_name}#{port}#{script_dirname}/"
-			end.sub(%r|/+$|, '/')
-		rescue SecurityError
-			''
-		end
-	end
-end
+require 'tdiary/cgi_compat'
 
-class RackCGI < CGI; end
+# the @cgi facade for Rack-hosted requests. Kept as a toplevel constant
+# because plugins switch behaviour with @cgi.is_a?(RackCGI).
+class RackCGI < TDiary::CGICompat; end
 
 # Local Variables:
 # mode: ruby

data/lib/tdiary/diary_container.rb

@@ -1,3 +1,6 @@
+require 'rack'
+require 'stringio'
+
 module TDiary
 	class DiaryContainer
 		# YYYYMMDD
@@ -16,13 +19,12 @@ module TDiary
 		end
 
 		def initialize(conf, year, month, day = nil)
-			cgi = FakeCGI.new
 			if year && month && day
-				cgi.params['date'] = ["#{year}#{month}#{day}"]
-				@controller = TDiaryDayWithoutFilter::new(cgi, '', conf)
+				request = build_request("#{year}#{month}#{day}")
+				@controller = TDiaryDayWithoutFilter::new(request, '', conf)
 			elsif year && month
-				cgi.params['date'] = ["#{year}#{month}"]
-				@controller = TDiaryMonthWithoutFilter::new(cgi, '', conf)
+				request = build_request("#{year}#{month}")
+				@controller = TDiaryMonthWithoutFilter::new(request, '', conf)
 			else
 				raise StandardError.new
 			end
@@ -37,11 +39,21 @@ module TDiary
 			@controller.diaries
 		end
 
-		class FakeCGI < CGI
-			def refeter; nil end
-			def user_agent; nil; end
-			def mobile_agent?; nil; end
-			def request_method; 'GET'; end
+	private
+
+		# there is no real HTTP request behind a container lookup; fake one
+		# with a minimal Rack env carrying the date parameter
+		def build_request(date)
+			TDiary::Request.new(
+				'REQUEST_METHOD'  => 'GET',
+				'SCRIPT_NAME'     => '',
+				'PATH_INFO'       => '/',
+				'QUERY_STRING'    => "date=#{date}",
+				'SERVER_NAME'     => 'localhost',
+				'SERVER_PORT'     => '80',
+				'rack.url_scheme' => 'http',
+				'rack.input'      => StringIO.new('')
+			)
 		end
 	end
 end
@@ -52,4 +64,4 @@ end
 # tab-width: 3
 # ruby-indent-level: 3
 # End:
-# vim: ts=3
+# vim: ts=3

data/lib/tdiary/dispatcher/index_main.rb

@@ -1,16 +1,16 @@
 module TDiary
 	class Dispatcher
 		class IndexMain
-			def self.run( request, cgi )
-				new( request, cgi ).run
+			def self.run( request )
+				new( request ).run
 			end
 
 			attr_reader :request, :cgi, :conf, :tdiary, :params
 
-			def initialize( request, cgi )
+			def initialize( request )
 				@request = request
-				@cgi = cgi
-				@conf = TDiary::Configuration::new( cgi, request )
+				@cgi = request.cgi_compat
+				@conf = TDiary::Configuration::new( request )
 				@params = request.params
 			end
 
@@ -36,7 +36,7 @@ module TDiary
 							require 'openssl'
 							body = tdiary.eval_rhtml
 							head['etag'] = %Q["#{OpenSSL::Digest::SHA256.hexdigest( body )}"]
-							if ENV['HTTP_IF_NONE_MATCH'] == head['etag'] and request.get? then
+							if request.env['HTTP_IF_NONE_MATCH'] == head['etag'] and request.get? then
 								head['status'] = CGI::HTTP_STATUS['NOT_MODIFIED']
 							else
 								head['charset'] = conf.encoding
@@ -78,31 +78,31 @@ module TDiary
 			def create_tdiary
 				begin
 					if params['comment']
-						tdiary = TDiary::TDiaryComment::new( cgi, "day.rhtml", conf )
+						tdiary = TDiary::TDiaryComment::new( request, "day.rhtml", conf )
 					elsif params['plugin']
-						tdiary = TDiary::TDiaryPluginView::new( cgi, '', conf )
+						tdiary = TDiary::TDiaryPluginView::new( request, '', conf )
 					elsif (date = params['date'])
 						if /^\d{8}-\d+$/ =~ date
-							tdiary = TDiary::TDiaryLatest::new( cgi, "latest.rhtml", conf )
+							tdiary = TDiary::TDiaryLatest::new( request, "latest.rhtml", conf )
 						elsif /^\d{8}$/ =~ date
-							tdiary = TDiary::TDiaryDay::new( cgi, "day.rhtml", conf )
+							tdiary = TDiary::TDiaryDay::new( request, "day.rhtml", conf )
 						elsif /^\d{6}$/ =~ date
-							tdiary = TDiary::TDiaryMonth::new( cgi, "month.rhtml", conf )
+							tdiary = TDiary::TDiaryMonth::new( request, "month.rhtml", conf )
 						elsif /^\d{4}$/ =~ date
-							tdiary = TDiary::TDiaryNYear::new( cgi, "month.rhtml", conf )
+							tdiary = TDiary::TDiaryNYear::new( request, "month.rhtml", conf )
 						end
 					elsif params['category']
-						tdiary = TDiary::TDiaryCategoryView::new( cgi, "category.rhtml", conf )
+						tdiary = TDiary::TDiaryCategoryView::new( request, "category.rhtml", conf )
 					elsif params['q']
-						tdiary = TDiary::TDiarySearch::new( cgi, "search.rhtml", conf )
+						tdiary = TDiary::TDiarySearch::new( request, "search.rhtml", conf )
 					else
-						tdiary = TDiary::TDiaryLatest::new( cgi, "latest.rhtml", conf )
+						tdiary = TDiary::TDiaryLatest::new( request, "latest.rhtml", conf )
 					end
 				rescue TDiary::PermissionError
 					raise
 				rescue TDiary::TDiaryError
 				end
-				( tdiary ? tdiary : TDiary::TDiaryLatest::new( cgi, "latest.rhtml", conf ) )
+				( tdiary ? tdiary : TDiary::TDiaryLatest::new( request, "latest.rhtml", conf ) )
 			end
 		end
 	end