tennpipes-base 3.6.6

data/lib/tennpipes-base/module.rb

@@ -0,0 +1,58 @@
+module Tennpipes
+  module Module
+    attr_accessor :root
+
+    ##
+    # Register this module as being loaded from a gem. This automatically
+    # sets the root and therefore the dependency paths correctly.
+    #
+    # @param [String] name
+    #   The name of the gem. Has to be the name as stated in the gemspec.
+    #
+    # @returns the gems root.
+    def gem!(name)
+      self.root = Tennpipes.gem(name, self)
+    end
+
+    ##
+    # Helper method for file references within a Tennpipes module.
+    #
+    # @param [Array<String>] args
+    #   The directories to join to {Module.root}.
+    #
+    # @return [String]
+    #   The absolute path.
+    #
+    # @example
+    #   module MyModule
+    #     extend Tennpipes::Module
+    #     gem! 'my_gem'
+    #   end
+    #   Module.root!
+    def root(*args)
+      File.expand_path(File.join(@root, *args))
+    end
+
+    ##
+    # Returns the list of path globs to load as dependencies.
+    # Appends custom dependency patterns to the be loaded for Tennpipes.
+    #
+    # @return [Array<String>]
+    #   The dependency paths.
+    #
+    # @example
+    #   module MyModule
+    #     extend Tennpipes::Module
+    #     gem! 'my_gem'
+    #   end
+    #
+    #   Module.dependency_paths << "#{MyModule.root}/uploaders/*.rb"
+    #
+    def dependency_paths
+      [
+        "#{root}/lib/**/*.rb", "#{root}/shared/lib/**/*.rb",
+        "#{root}/models/**/*.rb", "#{root}/shared/models/**/*.rb"
+      ]
+    end
+  end
+end

data/lib/tennpipes-base/mounter.rb

@@ -0,0 +1,308 @@
+require 'delegate'
+
+module Tennpipes
+  ##
+  # Represents a particular mounted Tennpipes application.
+  # Stores the name of the application (app folder name) and url mount path.
+  #
+  # @example
+  #   Mounter.new("blog_app", :app_class => "Blog").to("/blog")
+  #   Mounter.new("blog_app", :app_file => "/path/to/blog/app.rb").to("/blog")
+  #
+  class Mounter
+    DEFAULT_CASCADE = [404, 405]
+    class MounterException < RuntimeError
+    end
+
+    class ApplicationWrapper < SimpleDelegator
+      attr_accessor :uri_root
+      attr_writer :public_folder
+
+      def initialize(app, options = {})
+        @options = options
+        super(app)
+      end
+
+      def dependencies
+        @__dependencies ||= Dir["#{root}/**/*.rb"]
+      end
+
+      def prerequisites
+        @__prerequisites ||= []
+      end
+
+      def app_file
+        return @__app_file if @__app_file
+        obj = __getobj__
+        @__app_file = obj.respond_to?(:app_file) ? obj.app_file : @options[:app_file]
+      end
+
+      def root
+        return @__root if @__root
+        obj = __getobj__
+        @__root = obj.respond_to?(:root) ? obj.root : File.expand_path("#{app_file}/../")
+      end
+
+      def public_folder
+        return @public_folder if @public_folder
+        obj = __getobj__
+        @public_folder = obj.respond_to?(:public_folder) ? obj.public_folder : ""
+      end
+
+      def app_name
+        @__app_name ||= @options[:app_name] || __getobj__.to_s.underscore.to_sym
+      end
+
+      def setup_application!
+        @configured ||=
+          begin
+            $LOAD_PATH.concat(prerequisites)
+            Tennpipes.require_dependencies(dependencies, :force => true) if root.start_with?(Tennpipes.root)
+            true
+          end
+      end
+    end
+
+    attr_accessor :name, :uri_root, :app_file, :app_class, :app_root, :app_obj, :app_host, :cascade
+
+    ##
+    # @param [String, Tennpipes::Application] name
+    #   The app name or the {Tennpipes::Application} class.
+    #
+    # @param [Hash] options
+    # @option options [Symbol] :app_class (Detected from name)
+    # @option options [Symbol] :app_file (Automatically detected)
+    # @option options [Symbol] :app_obj (Detected)
+    # @option options [Symbol] :app_root (Directory of :app_file)
+    # @option options [Symbol] :gem The gem to load the app from (Detected from name)
+    #
+    def initialize(name, options={})
+      @name      = name.to_s
+      @app_class = options[:app_class] || @name.camelize
+      @gem       = options[:gem]       || @app_class.split("::").first.underscore
+      @app_file  = options[:app_file]  || locate_app_file
+      @app_obj   = options[:app_obj]   || app_constant || locate_app_object
+      ensure_app_file! || ensure_app_object!
+      @app_obj   = ApplicationWrapper.new(@app_obj, options) unless tennpipes_application?
+      @app_root  = options[:app_root]  || (@app_obj.respond_to?(:root) && @app_obj.root || File.dirname(@app_file))
+      @uri_root  = "/"
+      @cascade   = options[:cascade] ? true == options[:cascade] ? DEFAULT_CASCADE.dup : Array(options[:cascade]) : []
+      Tennpipes::Reloader.exclude_constants << @app_class
+    end
+
+    def tennpipes_application?
+      @app_obj.ancestors.include?(Tennpipes::Application)
+    rescue NameError
+      false
+    end
+
+    ##
+    # Registers the mounted application onto Tennpipes.
+    #
+    # @param [String] mount_url
+    #   Path where we mount the app.
+    #
+    # @example
+    #   Mounter.new("blog_app").to("/blog")
+    #
+    def to(mount_url)
+      @uri_root  = mount_url
+      Tennpipes.insert_mounted_app(self)
+      self
+    end
+
+    ##
+    # Registers the mounted application onto Tennpipes for the given host.
+    #
+    # @param [String] mount_host
+    #   Host name.
+    #
+    # @example
+    #   Mounter.new("blog_app").to("/blog").host("blog.tennpipes.org")
+    #   Mounter.new("blog_app").host("blog.tennpipes.org")
+    #   Mounter.new("catch_all").host(/.*\.tennpipes.org/)
+    #
+    def host(mount_host)
+      @app_host = mount_host
+      Tennpipes.insert_mounted_app(self)
+      self
+    end
+
+    ##
+    # Maps Tennpipes application onto a Tennpipes::Router.
+    # For use in constructing a Rack application.
+    #
+    # @param [Tennpipes::Router]
+    #
+    # @return [Tennpipes::Router]
+    #
+    # @example
+    #   @app.map_onto(router)
+    #
+    def map_onto(router)
+      app_data = self
+      app_obj = @app_obj
+      if tennpipes_application?
+        app_obj.set :uri_root,       app_data.uri_root
+        app_obj.set :app_name,       app_data.app_obj.app_name.to_s
+        app_obj.set :app_file,       app_data.app_file unless File.exist?(app_obj.app_file)
+        app_obj.set :root,           app_data.app_root unless app_data.app_root.blank?
+        app_obj.set :public_folder,  Tennpipes.root('public', app_data.uri_root) unless File.exist?(app_obj.public_folder)
+        app_obj.set :static,         File.exist?(app_obj.public_folder) if app_obj.nil?
+        app_obj.set :cascade,        app_data.cascade
+      else
+        app_obj.uri_root      = app_data.uri_root
+        app_obj.public_folder = Tennpipes.root('public', app_data.uri_root) unless File.exist?(app_obj.public_folder)
+      end
+      app_obj.setup_application! # Initializes the app here with above settings.
+      router.map(:to => app_obj, :path => app_data.uri_root, :host => app_data.app_host)
+    end
+
+    ###
+    # Returns the route objects for the mounted application.
+    #
+    def routes
+      app_obj.routes
+    end
+
+    ###
+    # Returns the basic route information for each named route.
+    #
+    # @return [Array]
+    #   Array of routes.
+    #
+    def named_routes
+      app_obj.routes.map { |route|
+        route_name = route.name.to_s
+        route_name = 
+          if route.controller
+            route_name.split(" ", 2).map{|name| ":#{name}" }.join(", ")
+          else
+            ":#{route_name}"
+          end
+        name_array = "(#{route_name})"
+        request_method = route.request_methods.first
+        next if route.name.blank? || request_method == 'HEAD'
+        original_path = route.original_path.is_a?(Regexp) ? route.original_path.inspect : route.original_path
+        full_path = File.join(uri_root, original_path)
+        OpenStruct.new(:verb => request_method, :identifier => route.name, :name => name_array, :path => full_path)
+      }.compact
+    end
+
+    ##
+    # Makes two Mounters equal if they have the same name and uri_root.
+    #
+    # @param [Tennpipes::Mounter] other
+    #
+    def ==(other)
+      other.is_a?(Mounter) && self.app_class == other.app_class && self.uri_root == other.uri_root
+    end
+
+    ##
+    # @return [Tennpipes::Application]
+    #  the class object for the app if defined, nil otherwise.
+    #
+    def app_constant
+      klass = Object
+      for piece in app_class.split("::")
+        piece = piece.to_sym
+        if klass.const_defined?(piece, false)
+          klass = klass.const_get(piece)
+        else
+          return
+        end
+      end
+      klass
+    end
+
+    protected
+    ##
+    # Locates and requires the file to load the app constant.
+    #
+    def locate_app_object
+      @_app_object ||= begin
+        ensure_app_file!
+        Tennpipes.require_dependencies(app_file)
+        app_constant
+      end
+    end
+
+    ##
+    # Returns the determined location of the mounted application main file.
+    #
+    def locate_app_file
+      candidates  = []
+      candidates << app_constant.app_file if app_constant.respond_to?(:app_file) && File.exist?(app_constant.app_file.to_s)
+      candidates << Tennpipes.first_caller if File.identical?(Tennpipes.first_caller.to_s, Tennpipes.called_from.to_s)
+      candidates << Tennpipes.mounted_root(name.downcase, "app.rb")
+      simple_name = name.split("::").last.downcase
+      mod_name = name.split("::")[0..-2].join("::")
+      Tennpipes.modules.each do |mod|
+        if mod.name == mod_name
+          candidates << mod.root(simple_name, "app.rb")
+        end
+      end
+      candidates << Tennpipes.root("app", "app.rb")
+      candidates.find { |candidate| File.exist?(candidate) }
+    end
+
+    ###
+    # Raises an exception unless app_file is located properly.
+    #
+    def ensure_app_file!
+      message = "Unable to locate source file for app '#{app_class}', try with :app_file => '/path/app.rb'"
+      raise MounterException, message unless @app_file
+    end
+
+    ###
+    # Raises an exception unless app_obj is defined properly.
+    #
+    def ensure_app_object!
+      message = "Unable to locate app for '#{app_class}', try with :app_class => 'MyAppClass'"
+      raise MounterException, message unless @app_obj
+    end
+  end
+
+  class << self
+    attr_writer :mounted_root # Set root directory where tennpipes searches mounted apps
+
+    ##
+    # @param [Array] args
+    #
+    # @return [String]
+    #   the root to the mounted apps base directory.
+    #
+    def mounted_root(*args)
+      Tennpipes.root(@mounted_root ||= "", *args)
+    end
+
+    ##
+    # @return [Array]
+    #   the mounted tennpipes applications (MountedApp objects)
+    #
+    def mounted_apps
+      @mounted_apps ||= []
+    end
+
+    ##
+    # Inserts a Mounter object into the mounted applications (avoids duplicates).
+    #
+    # @param [Tennpipes::Mounter] mounter
+    #
+    def insert_mounted_app(mounter)
+      Tennpipes.mounted_apps.push(mounter) unless Tennpipes.mounted_apps.include?(mounter)
+    end
+
+    ##
+    # Mounts a new sub-application onto Tennpipes project.
+    #
+    # @see Tennpipes::Mounter#new
+    #
+    # @example
+    #   Tennpipes.mount("blog_app").to("/blog")
+    #
+    def mount(name, options={})
+      Mounter.new(name, options)
+    end
+  end
+end

data/lib/tennpipes-base/path_router.rb

@@ -0,0 +1,119 @@
+require 'tennpipes-base/path_router/error_handler'
+require 'tennpipes-base/path_router/route'
+require 'tennpipes-base/path_router/matcher'
+require 'tennpipes-base/path_router/compiler'
+
+module Tennpipes
+  ##
+  # Provides an HTTP router for use in path routing.
+  #
+  module PathRouter
+    ##
+    # Constructs an instance of PathRouter::Router.
+    #
+    def self.new
+      Router.new
+    end
+
+    class Router
+      attr_reader :current_order, :routes, :engine
+
+      ##
+      # Constructs an instance of PathRouter::Router.
+      #
+      def initialize
+        reset!
+      end
+
+      ##
+      # Adds a new route to routes.
+      #
+      def add(verb, path, options = {}, &block)
+        route = Route.new(path, verb, options, &block)
+        route.router = self
+        @routes << route
+        route
+      end
+
+      ##
+      # Returns all routes which are matched with the condition
+      #
+      def call(request, &block)
+        prepare! unless prepared?
+        @engine.call_by_request(request, &block)
+      end
+
+      ##
+      # Returns all routes which are matched with the condition without block
+      #
+      def recognize(request_or_env)
+        prepare! unless prepared?
+        @engine.find_by(request_or_env)
+      end
+
+      ##
+      # Finds a path which is matched with conditions from arguments
+      #
+      def path(name, *args)
+        params = args.extract_options!
+        @routes.each do |route|
+          next unless route.name == name
+          matcher = route.matcher
+          params_for_expand = params.dup
+          if !args.empty? && matcher.mustermann?
+            matcher.names.each_with_index do |matcher_name, index|
+              params_for_expand[matcher_name.to_sym] ||= args[index]
+            end
+          end
+          return matcher.mustermann? ? matcher.expand(params_for_expand) : route.path_for_generation
+        end
+        fail InvalidRouteException
+      end
+
+      ##
+      # Recognizes route and expanded params from a path.
+      #
+      def recognize_path(path_info)
+        prepare! unless prepared?
+        route = @engine.find_by_pattern(path_info).first
+        [route.name, route.params_for(path_info, {})]
+      end
+
+      ##
+      # Resets all routes, current order and preparation.
+      #
+      def reset!
+        @routes = []
+        @current_order = 0
+        @prepared = nil
+      end
+
+      ##
+      # Increments the order.
+      #
+      def increment_order
+        @current_order += 1
+      end
+
+      ##
+      # Constructs an instance of PathRouter::Compiler,
+      # and sorts all routes by using the order.
+      #
+      def prepare!
+        @engine = Compiler.new(@routes)
+        @prepared = true
+        return if @current_order.zero?
+        @routes.sort_by!(&:order)
+      end
+
+      private
+
+      ##
+      # Returns true if the router has been prepared.
+      #
+      def prepared?
+        !!@prepared
+      end
+    end
+  end
+end