Permalink
Browse files

Remove Sinatra::Decompile API

This extension is obsolete as Sinatra now provides access to a pattern object,
thanks to Mustermann, so that we no longer need to decompose Regexps.

If you're using this API directly, or via an extension that I'm unaware of...
Please let me know and we'll figure something out.

Its highly likely noone was using this extension directly, and possible that
only Namespace was the only consumer via internal usage.

So for now, I'm removing this extension until someone complains.
  • Loading branch information...
zzak committed May 17, 2016
1 parent 6cf32bb commit 3c96ef05ea7a9487eabc5d4da466919bc411aa1b
@@ -58,9 +58,6 @@ existing APIs.
Currently included:
-* `sinatra/decompile`: Recreates path patterns from Sinatra's internal data
- structures (used by other extensions).
-
* `sinatra/reloader`: Automatically reloads Ruby files on code changes.
## Other Tools
@@ -26,7 +26,6 @@ module Common
# Other extensions you don't want to be loaded unless needed.
module Custom
# register :Compass
- register :Decompile
register :Reloader
end
@@ -1,127 +0,0 @@
-require 'sinatra/base'
-require 'backports'
-require 'uri'
-
-module Sinatra
-
- # = Sinatra::Decompile
- #
- # <tt>Sinatra::Decompile</tt> is an extension that provides a method,
- # conveniently called +decompile+, that will generate a String pattern for a
- # given route.
- #
- # == Usage
- #
- # === Classic Application
- #
- # To use the extension in a classic application all you need to do is require
- # it:
- #
- # require "sinatra"
- # require "sinatra/decompile"
- #
- # # Your classic application code goes here...
- #
- # This will add the +decompile+ method to the application/class scope, but
- # you can also call it as <tt>Sinatra::Decompile.decompile</tt>.
- #
- # === Modular Application
- #
- # To use the extension in a modular application you need to require it, and
- # then, tell the application you will use it:
- #
- # require "sinatra/base"
- # require "sinatra/decompile"
- #
- # class MyApp < Sinatra::Base
- # register Sinatra::Decompile
- #
- # # The rest of your modular application code goes here...
- # end
- #
- # This will add the +decompile+ method to the application/class scope. You
- # can choose not to register the extension, but instead of calling
- # +decompile+, you will need to call <tt>Sinatra::Decompile.decompile</tt>.
- #
- module Decompile
- extend self
-
- ##
- # Regenerates a string pattern for a given route
- #
- # Example:
- #
- # class Sinatra::Application
- # routes.each do |verb, list|
- # puts "#{verb}:"
- # list.each do |data|
- # puts "\t" << decompile(data)
- # end
- # end
- # end
- #
- # Will return the internal Regexp if it's unable to reconstruct the pattern,
- # which likely indicates that a Regexp was used in the first place.
- #
- # You can also use this to check whether you could actually use a string
- # pattern instead of your regexp:
- #
- # decompile /^/foo$/ # => '/foo'
- def decompile(pattern, keys = nil, *)
- # Everything in here is basically just the reverse of
- # Sinatra::Base#compile
- #
- # Sinatra 2.0 will come with a mechanism for this, making this obsolete.
- pattern, keys = pattern if pattern.respond_to? :to_ary
- keys, str = keys.try(:dup), pattern.inspect
- return pattern unless str.start_with? '/' and str.end_with? '/'
- str.gsub! /^\/(\^|\\A)?|(\$|\\z)?\/$/, ''
- str.gsub! encoded(' '), ' '
- return pattern if str =~ /^[\.\+]/
- str.gsub! '((?:[^\.\/?#%]|(?:%[^2].|%[2][^Ee]))+)', '([^\/?#]+)'
- str.gsub! '((?:[^\/?#%]|(?:%[^2].|%[2][^Ee]))+)', '([^\/?#]+)'
- str.gsub! /\([^\(\)]*\)|\([^\(\)]*\([^\(\)]*\)[^\(\)]*\)/ do |part|
- case part
- when '(.*?)'
- return pattern if keys.shift != 'splat'
- '*'
- when /^\(\?\:(\\*.)\|%[\w\[\]]+\)$/
- $1
- when /^\(\?\:(%\d+)\|([^\)]+|\([^\)]+\))\)$/
- URI.unescape($1)
- when '([^\/?#]+)'
- return pattern if keys.empty?
- ":" << keys.shift
- when /^\(\?\:\\?(.)\|/
- char = $1
- return pattern unless encoded(char) == part
- Regexp.escape(char)
- else
- return pattern
- end
- end
- str.gsub /(.)([\.\+\(\)\/])/ do
- return pattern if $1 != "\\"
- $2
- end
- end
-
- private
-
- def encoded(char)
- return super if defined? super
- enc = uri_parser.escape(char)
- enc = "(?:#{escaped(char, enc).join('|')})" if enc == char
- enc = "(?:#{enc}|#{encoded('+')})" if char == " "
- enc
- end
-
- def uri_parser
- #TODO: Remove check after dropping support for 1.8.7
- @_uri_parser ||= defined?(URI::Parser) ? URI::Parser.new : URI
- end
-
- end
-
- register Decompile
-end
@@ -1,6 +1,5 @@
require 'backports'
require 'sinatra/base'
-require 'sinatra/decompile'
module Sinatra
@@ -163,7 +162,6 @@ def namespace(pattern, conditions = {}, &block)
module NamespacedMethods
include SharedMethods
- include Sinatra::Decompile
attr_reader :base, :templates
def self.prefixed(*names)
@@ -137,7 +137,6 @@ Gem::Specification.new do |s|
"lib/sinatra/contrib/version.rb",
"lib/sinatra/cookies.rb",
"lib/sinatra/custom_logger.rb",
- "lib/sinatra/decompile.rb",
"lib/sinatra/engine_tracking.rb",
"lib/sinatra/extension.rb",
"lib/sinatra/json.rb",
@@ -193,7 +192,6 @@ Gem::Specification.new do |s|
"spec/content_for_spec.rb",
"spec/cookies_spec.rb",
"spec/custom_logger_spec.rb",
- "spec/decompile_spec.rb",
"spec/extension_spec.rb",
"spec/json_spec.rb",
"spec/link_header_spec.rb",
@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-RSpec::Matchers.define :decompile do |path|
- match do |app|
- @compiled, @keys = app.send :compile, path
- @decompiled = app.decompile(@compiled, @keys)
- @decompiled.should == path
- end
-
- failure_message_for_should do |app|
- values = [app, @compiled, @keys, path, @decompiled].map(&:inspect)
- "expected %s to decompile %s with %s to %s, but was %s" % values
- end
-end
-
-describe Sinatra::Decompile do
- subject { Sinatra::Application }
- it { should decompile("") }
- it { should decompile("/") }
- it { should decompile("/?") }
- it { should decompile("/foo") }
- it { should decompile("/:name") }
- it { should decompile("/:name?") }
- it { should decompile("/:foo/:bar") }
- it { should decompile("/page/:id/edit") }
- it { should decompile("/hello/*") }
- it { should decompile("/*/foo/*") }
- it { should decompile("*") }
- it { should decompile(":name.:format") }
- it { should decompile("a b") }
- it { should decompile("a+b") }
- it { should decompile(/./) }
- it { should decompile(/f(oo)/) }
- it { should decompile(/ba+r/) }
-
- it 'just returns strings' do
- subject.decompile('/foo').should == '/foo'
- end
-
- it 'just decompile simple regexps without keys' do
- subject.decompile(%r{/foo}).should == '/foo'
- end
-end

0 comments on commit 3c96ef0

Please sign in to comment.