sinatra-named-routes-subdomains 0.1.0

data/Gemfile

@@ -0,0 +1,15 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in sinatra-named-routes.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rake'
+  gem 'sinatra-contrib'
+  gem 'rspec'
+  gem 'guard-rspec'
+end
+
+group :test do
+  gem 'simplecov', :require => false
+end

data/README.md

@@ -0,0 +1,14 @@
+# Sinatra Named Routes w/ Subdomain support
+
+Based on sinatra-named-routes by ckhampus: https://github.com/ckhampus/sinatra-named-routes.
+
+## Subdomain Usage
+
+```ruby
+map :named_route, '/myroute/:some_id'
+url( :named_route, true, :some_id => 123, :subdomain => 'mysubdomain' )
+```
+
+```
+http://mysubdomain.myhost.com/myroute/123
+```

data/lib/sinatra/named_routes.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(__FILE__), 'version')
+require File.join(File.dirname(__FILE__), 'route_parser')
+
+module Sinatra
+  module NamedRoutes
+    module Helpers
+
+      # Generates the absolute URI for a given path in the app.
+      # Takes Rack routers and reverse proxies into account.
+      # Extended support passing in named route and parameters.
+      def uri( addr = nil, absolute = true, params = nil )
+        if addr.is_a? Symbol
+          addr = NamedRoutes.get_path( addr, params )
+        end
+
+        return addr if addr =~ /\A[A-z][A-z0-9\+\.\-]*:/
+
+        uri = [host = ""]
+        if absolute
+          host << "http#{'s' if request.secure?}://"
+          if request.forwarded? or request.port != (request.secure? ? 443 : 80)
+            domain = request.host_with_port
+          else
+            domain = request.host
+          end
+
+          if !params.nil? && !params[:subdomain].nil?
+            host << domain.gsub(/^([a-zA-Z-]+)\./, "#{params[:subdomain]}.")
+          else
+            host << domain
+          end
+        end
+
+        uri << (addr ? addr : request.path_info).to_s
+        File.join uri
+      end
+
+      alias :to :uri
+      alias :url :uri
+    end
+
+    # Maps a path to name.
+    def map(name, path)
+      NamedRoutes.routes[name] = Route.new path
+    end
+    
+    alias :bind :map
+
+    private
+
+    def route(verb, path, options={}, &block)
+      if path.is_a?(Symbol)
+        path = NamedRoutes.routes[path].source
+      end
+
+      super(verb, path, options, &block)
+    end
+
+    def self.get_path(name, params = {})
+      raise ArgumentError, "No route with the name #{name} exists." if NamedRoutes.routes.nil?
+      NamedRoutes.routes[name].build params
+    end
+
+    def self.routes
+      @@routes ||= {}
+    end
+
+    def self.registered(app)
+      app.helpers NamedRoutes::Helpers
+    end
+  end
+end

data/lib/sinatra/route_parser.rb

@@ -0,0 +1,175 @@
+module Sinatra
+  module BlueRoutes
+    class Route
+      attr_reader :source
+
+      def initialize(route)
+        route = route.source if route.is_a? Regexp
+
+        @source = route
+        @input = StringScanner.new(route)
+        @output = []
+
+        parse
+      end
+
+      def build(params = {})
+        path = []
+        params = {} if params.nil?
+
+        @output.each_index do |index|
+          item = @output[index]
+          next_item = @output.fetch(index + 1, nil)
+
+          case item[:token]
+          when :slash
+            @trailing_slash = item[:optional]
+            path << '/'
+          when :dot
+            @trailing_dot = item[:optional]
+            path << '.'
+          when :plus
+            path << '+'
+          when :splat
+            if params.is_a? Hash
+              raise ArgumentError, 'No parameters passed.' if params[:splat].empty?
+              path << params[:splat].shift
+            else
+              raise ArgumentError, 'No enough parameters passed.' if params.empty?
+              path << params.shift
+            end
+          when :path
+            path << item[:value]
+          when :named_param
+            item_key = item[:value]
+
+            if params.has_key? item_key
+              path << params.delete(item_key)
+            else
+              raise ArgumentError, "No value passed for '#{item_key.to_s}'" unless item[:optional]
+            end
+          when :regexp
+            name = /#{item[:value]}/.names
+
+            if name.any?
+              name = name.first.to_sym
+
+              if params.has_key? name
+                path << params.delete(name)
+              else
+                raise ArgumentError, "No value passed for '#{name.to_s}'" unless item[:optional]
+              end
+            else
+              if params.is_a? Hash
+                raise ArgumentError, 'No enough parameters passed.' if params[:captures].empty? and !item[:optional]
+                path << params[:captures].shift
+              else
+                raise ArgumentError, 'No enough parameters passed.' if params.empty?
+                path << params.shift
+              end
+            end
+          end
+        end
+
+        path = path.join
+
+        if @trailing_dot
+          path = path.chomp '.'
+        end
+
+        if @trailing_slash
+          path = path.chomp '/'
+        end
+
+        path
+      end
+
+      private
+
+      def is_optional?
+        @output.last[:optional] = @input.scan(/\?/) ? true : false
+      end
+
+      def parse
+        while token = parse_slash || parse_path || parse_named_param || 
+                      parse_dot || parse_plus || parse_splat || parse_regexp
+          @output << token
+          is_optional?
+        end
+      end
+
+      def parse_slash
+        if @input.scan(/\//)
+          {
+            :token => :slash
+          }
+        else
+          nil
+        end
+      end
+
+      def parse_dot
+        if @input.scan(/\./)
+          {
+            :token => :dot
+          }
+        else
+          nil
+        end
+      end
+
+      def parse_plus
+        if @input.scan(/\+/)
+          {
+            :token => :plus
+          }
+        else
+          nil
+        end
+      end
+
+      def parse_splat
+        if @input.scan(/\*/)
+          {
+            :token => :splat
+          }
+        else
+          nil
+        end
+      end
+
+      def parse_path
+        if @input.scan(/\w+/)
+          {
+            :token => :path,
+            :value => @input.matched
+          }
+        else
+          nil
+        end
+      end
+
+      def parse_named_param
+        if @input.scan(/:[^\W]*/)
+          {
+            :token => :named_param,
+            :value => @input.matched.sub(':', '').to_sym
+          }
+        else
+          nil
+        end
+      end
+
+      def parse_regexp
+        if @input.scan(/\([^\)]*\)/)
+          {
+            :token => :regexp,
+            :value => @input.matched
+          }
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module BlueRoutes
+    VERSION = '0.1.0'
+  end
+end

data/sinatra-named-routes-subdomains.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'sinatra/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'sinatra-named-routes-subdomains'
+  s.version     = Sinatra::BlueRoutes::VERSION
+  s.authors     = ['Adam Zerlin']
+  s.email       = ['adam@adamzerlin.com']
+  s.homepage    = 'https://github.com/adamzerlin/sinatra-named-routes'
+  s.summary     = %q{Named Routes for Sinatra with Subdomains}
+  s.description = %q{Allows the use of named routes and custom subdomains in Sinatra applications.  Based heavily on ckhampus' sinatra-named-routes.}
+
+  s.rubyforge_project = 'sinatra-named-routes-subdomains'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'sinatra'
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-named-routes-subdomains
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease:
+platform: ruby
+authors:
+- Adam Zerlin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :runtime
+description: Allows the use of named routes and custom subdomains in Sinatra applications.  Based heavily on ckhampus' sinatra-named-routes.
+email:
+- adam@adamzerlin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- lib/sinatra/named_routes.rb
+- lib/sinatra/route_parser.rb
+- lib/sinatra/version.rb
+- sinatra-named-routes-0.1.0.gem
+- sinatra-named-routes-subdomains.gemspec
+homepage: https://github.com/adamzerlin/sinatra-named-routes
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project: sinatra-named-routes-subdomains
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Named Routes for Sinatra with Subdomains
+test_files: []