Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP

Loading…

Reindent some chunks of code #699

Merged
merged 1 commit into from

2 participants

@patriciomacadden

It bothered me the fact that some chunks of code are indented like this:

  def some_method
    # ...
  end

  private

  def some_other_method
    # ...
  end

and some others like this:

  def some_method
    # ...
  end

private
  def some_other_method
    # ...
  end

and others like this:

def some_method
    # ...
  end

private
def some_other_method
  # ...
end

So I've modified those chunks of code that looks like the second and third style to look like the first one.

@rkh rkh merged commit 5c1bfff into sinatra:master

1 check passed

Details default The Travis build passed
@patriciomacadden patriciomacadden deleted the patriciomacadden:reindentation branch
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Commits on Mar 26, 2013
  1. @patriciomacadden
This page is out of date. Refresh to see the latest.
Showing with 167 additions and 158 deletions.
  1. +167 −158 lib/sinatra/base.rb
View
325 lib/sinatra/base.rb
@@ -756,6 +756,7 @@ def find_template(views, name, engine)
end
private
+
# logic shared between builder and nokogiri
def render_ruby(engine, template, options = {}, locals = {}, &block)
options, template = template, nil if template.is_a?(Hash)
@@ -929,189 +930,190 @@ def forward
nil
end
- private
- # Run filters defined on the class and all superclasses.
- def filter!(type, base = settings)
- filter! type, base.superclass if base.superclass.respond_to?(:filters)
- base.filters[type].each { |args| process_route(*args) }
- end
+ private
- # Run routes defined on the class and all superclasses.
- def route!(base = settings, pass_block = nil)
- if routes = base.routes[@request.request_method]
- routes.each do |pattern, keys, conditions, block|
- pass_block = process_route(pattern, keys, conditions) do |*args|
- route_eval { block[*args] }
+ # Run filters defined on the class and all superclasses.
+ def filter!(type, base = settings)
+ filter! type, base.superclass if base.superclass.respond_to?(:filters)
+ base.filters[type].each { |args| process_route(*args) }
+ end
+
+ # Run routes defined on the class and all superclasses.
+ def route!(base = settings, pass_block = nil)
+ if routes = base.routes[@request.request_method]
+ routes.each do |pattern, keys, conditions, block|
+ pass_block = process_route(pattern, keys, conditions) do |*args|
+ route_eval { block[*args] }
+ end
end
end
- end
- # Run routes defined in superclass.
- if base.superclass.respond_to?(:routes)
- return route!(base.superclass, pass_block)
- end
+ # Run routes defined in superclass.
+ if base.superclass.respond_to?(:routes)
+ return route!(base.superclass, pass_block)
+ end
- route_eval(&pass_block) if pass_block
- route_missing
- end
+ route_eval(&pass_block) if pass_block
+ route_missing
+ end
- # Run a route block and throw :halt with the result.
- def route_eval
- throw :halt, yield
- end
+ # Run a route block and throw :halt with the result.
+ def route_eval
+ throw :halt, yield
+ end
- # If the current request matches pattern and conditions, fill params
- # with keys and call the given block.
- # Revert params afterwards.
- #
- # Returns pass block.
- def process_route(pattern, keys, conditions, block = nil, values = [])
- route = @request.path_info
- route = '/' if route.empty? and not settings.empty_path_info?
- return unless match = pattern.match(route)
- values += match.captures.to_a.map { |v| force_encoding URI.decode(v) if v }
+ # If the current request matches pattern and conditions, fill params
+ # with keys and call the given block.
+ # Revert params afterwards.
+ #
+ # Returns pass block.
+ def process_route(pattern, keys, conditions, block = nil, values = [])
+ route = @request.path_info
+ route = '/' if route.empty? and not settings.empty_path_info?
+ return unless match = pattern.match(route)
+ values += match.captures.to_a.map { |v| force_encoding URI.decode(v) if v }
- if values.any?
- original, @params = params, params.merge('splat' => [], 'captures' => values)
- keys.zip(values) { |k,v| Array === @params[k] ? @params[k] << v : @params[k] = v if v }
- end
+ if values.any?
+ original, @params = params, params.merge('splat' => [], 'captures' => values)
+ keys.zip(values) { |k,v| Array === @params[k] ? @params[k] << v : @params[k] = v if v }
+ end
- catch(:pass) do
- conditions.each { |c| throw :pass if c.bind(self).call == false }
- block ? block[self, values] : yield(self, values)
+ catch(:pass) do
+ conditions.each { |c| throw :pass if c.bind(self).call == false }
+ block ? block[self, values] : yield(self, values)
+ end
+ ensure
+ @params = original if original
end
- ensure
- @params = original if original
- end
- # No matching route was found or all routes passed. The default
- # implementation is to forward the request downstream when running
- # as middleware (@app is non-nil); when no downstream app is set, raise
- # a NotFound exception. Subclasses can override this method to perform
- # custom route miss logic.
- def route_missing
- if @app
- forward
- else
- raise NotFound
+ # No matching route was found or all routes passed. The default
+ # implementation is to forward the request downstream when running
+ # as middleware (@app is non-nil); when no downstream app is set, raise
+ # a NotFound exception. Subclasses can override this method to perform
+ # custom route miss logic.
+ def route_missing
+ if @app
+ forward
+ else
+ raise NotFound
+ end
end
- end
- # Attempt to serve static files from public directory. Throws :halt when
- # a matching file is found, returns nil otherwise.
- def static!
- return if (public_dir = settings.public_folder).nil?
- public_dir = File.expand_path(public_dir)
+ # Attempt to serve static files from public directory. Throws :halt when
+ # a matching file is found, returns nil otherwise.
+ def static!
+ return if (public_dir = settings.public_folder).nil?
+ public_dir = File.expand_path(public_dir)
- path = File.expand_path(public_dir + unescape(request.path_info))
- return unless path.start_with?(public_dir) and File.file?(path)
+ path = File.expand_path(public_dir + unescape(request.path_info))
+ return unless path.start_with?(public_dir) and File.file?(path)
- env['sinatra.static_file'] = path
- cache_control(*settings.static_cache_control) if settings.static_cache_control?
- send_file path, :disposition => nil
- end
-
- # Enable string or symbol key access to the nested params hash.
- def indifferent_params(object)
- case object
- when Hash
- new_hash = indifferent_hash
- object.each { |key, value| new_hash[key] = indifferent_params(value) }
- new_hash
- when Array
- object.map { |item| indifferent_params(item) }
- else
- object
+ env['sinatra.static_file'] = path
+ cache_control(*settings.static_cache_control) if settings.static_cache_control?
+ send_file path, :disposition => nil
end
- end
- # Creates a Hash with indifferent access.
- def indifferent_hash
- Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
- end
+ # Enable string or symbol key access to the nested params hash.
+ def indifferent_params(object)
+ case object
+ when Hash
+ new_hash = indifferent_hash
+ object.each { |key, value| new_hash[key] = indifferent_params(value) }
+ new_hash
+ when Array
+ object.map { |item| indifferent_params(item) }
+ else
+ object
+ end
+ end
- # Run the block with 'throw :halt' support and apply result to the response.
- def invoke
- res = catch(:halt) { yield }
- res = [res] if Fixnum === res or String === res
- if Array === res and Fixnum === res.first
- res = res.dup
- status(res.shift)
- body(res.pop)
- headers(*res)
- elsif res.respond_to? :each
- body res
- end
- nil # avoid double setting the same response tuple twice
- end
+ # Creates a Hash with indifferent access.
+ def indifferent_hash
+ Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+ end
- # Dispatch a request with error handling.
- def dispatch!
- invoke do
- static! if settings.static? && (request.get? || request.head?)
- filter! :before
- route!
+ # Run the block with 'throw :halt' support and apply result to the response.
+ def invoke
+ res = catch(:halt) { yield }
+ res = [res] if Fixnum === res or String === res
+ if Array === res and Fixnum === res.first
+ res = res.dup
+ status(res.shift)
+ body(res.pop)
+ headers(*res)
+ elsif res.respond_to? :each
+ body res
+ end
+ nil # avoid double setting the same response tuple twice
end
- rescue ::Exception => boom
- invoke { handle_exception!(boom) }
- ensure
- begin
- filter! :after unless env['sinatra.static_file']
+
+ # Dispatch a request with error handling.
+ def dispatch!
+ invoke do
+ static! if settings.static? && (request.get? || request.head?)
+ filter! :before
+ route!
+ end
rescue ::Exception => boom
- invoke { handle_exception!(boom) } unless @env['sinatra.error']
+ invoke { handle_exception!(boom) }
+ ensure
+ begin
+ filter! :after unless env['sinatra.static_file']
+ rescue ::Exception => boom
+ invoke { handle_exception!(boom) } unless @env['sinatra.error']
+ end
end
- end
- # Error handling during requests.
- def handle_exception!(boom)
- @env['sinatra.error'] = boom
+ # Error handling during requests.
+ def handle_exception!(boom)
+ @env['sinatra.error'] = boom
- if boom.respond_to? :http_status
- status(boom.http_status)
- elsif settings.use_code? and boom.respond_to? :code and boom.code.between? 400, 599
- status(boom.code)
- else
- status(500)
- end
+ if boom.respond_to? :http_status
+ status(boom.http_status)
+ elsif settings.use_code? and boom.respond_to? :code and boom.code.between? 400, 599
+ status(boom.code)
+ else
+ status(500)
+ end
- status(500) unless status.between? 400, 599
+ status(500) unless status.between? 400, 599
- if server_error?
- dump_errors! boom if settings.dump_errors?
- raise boom if settings.show_exceptions? and settings.show_exceptions != :after_handler
- end
+ if server_error?
+ dump_errors! boom if settings.dump_errors?
+ raise boom if settings.show_exceptions? and settings.show_exceptions != :after_handler
+ end
- if not_found?
- headers['X-Cascade'] = 'pass' if settings.x_cascade?
- body '<h1>Not Found</h1>'
- end
+ if not_found?
+ headers['X-Cascade'] = 'pass' if settings.x_cascade?
+ body '<h1>Not Found</h1>'
+ end
- res = error_block!(boom.class, boom) || error_block!(status, boom)
- return res if res or not server_error?
- raise boom if settings.raise_errors? or settings.show_exceptions?
- error_block! Exception, boom
- end
+ res = error_block!(boom.class, boom) || error_block!(status, boom)
+ return res if res or not server_error?
+ raise boom if settings.raise_errors? or settings.show_exceptions?
+ error_block! Exception, boom
+ end
- # Find an custom error block for the key(s) specified.
- def error_block!(key, *block_params)
- base = settings
- while base.respond_to?(:errors)
- next base = base.superclass unless args_array = base.errors[key]
- args_array.reverse_each do |args|
- first = args == args_array.first
- args += [block_params]
- resp = process_route(*args)
- return resp unless resp.nil? && !first
+ # Find an custom error block for the key(s) specified.
+ def error_block!(key, *block_params)
+ base = settings
+ while base.respond_to?(:errors)
+ next base = base.superclass unless args_array = base.errors[key]
+ args_array.reverse_each do |args|
+ first = args == args_array.first
+ args += [block_params]
+ resp = process_route(*args)
+ return resp unless resp.nil? && !first
+ end
end
+ return false unless key.respond_to? :superclass and key.superclass < Exception
+ error_block!(key.superclass, *block_params)
end
- return false unless key.respond_to? :superclass and key.superclass < Exception
- error_block!(key.superclass, *block_params)
- end
- def dump_errors!(boom)
- msg = ["#{boom.class} - #{boom.message}:", *boom.backtrace].join("\n\t")
- @env['rack.errors'].puts(msg)
- end
+ def dump_errors!(boom)
+ msg = ["#{boom.class} - #{boom.message}:", *boom.backtrace].join("\n\t")
+ @env['rack.errors'].puts(msg)
+ end
class << self
attr_reader :routes, :filters, :templates, :errors
@@ -1315,7 +1317,8 @@ def public_dir
public_folder
end
- private
+ private
+
# Dynamically defines a method on settings.
def define_singleton(name, content = Proc.new)
# replace with call to singleton_class once we're 1.9 only
@@ -1361,7 +1364,8 @@ def provides(*types)
end
end
- public
+ public
+
# Defining a `GET` handler also automatically defines
# a `HEAD` handler.
def get(path, opts = {}, &block)
@@ -1381,7 +1385,8 @@ def patch(path, opts = {}, &bk) route 'PATCH', path, opts, &bk end
def link(path, opts = {}, &bk) route 'LINK', path, opts, &bk end
def unlink(path, opts = {}, &bk) route 'UNLINK', path, opts, &bk end
- private
+ private
+
def route(verb, path, options = {}, &block)
# Because of self.options.host
host_name(options.delete(:host)) if options.key?(:host)
@@ -1517,7 +1522,8 @@ def safe_ignore(ignore)
end
end
- public
+ public
+
# Makes the methods defined in the block and in the Modules given
# in `extensions` available to the handlers and templates
def helpers(*extensions, &block)
@@ -1610,7 +1616,8 @@ def call(env)
synchronize { prototype.call(env) }
end
- private
+ private
+
def setup_default_middleware(builder)
builder.use ExtendedRack
builder.use ShowExceptions if show_exceptions?
@@ -1694,7 +1701,8 @@ def synchronize(&block)
end
end
- public
+ public
+
CALLERS_TO_IGNORE = [ # :nodoc:
/\/sinatra(\/(base|main|showexceptions))?\.rb$/, # all sinatra code
/lib\/tilt.*\.rb$/, # all tilt code
@@ -1724,7 +1732,8 @@ def caller_locations
cleaned_caller 2
end
- private
+ private
+
# used for deprecation warnings
def warn(message)
super message + "\n\tfrom #{cleaned_caller.first.join(':')}"
Something went wrong with that request. Please try again.