tennpipes-base 3.6.6

data/lib/tennpipes-base/path_router/compiler.rb

@@ -0,0 +1,110 @@
+module Tennpipes
+  module PathRouter
+    #
+    # High performance engine for finding all routes which are matched with pattern
+    #
+    class Compiler
+      # All regexps generated by recursive compiler
+      attr_reader :regexps
+
+      ##
+      # Constructs an instance of Tennpipes::PathRouter::Compiler
+      #
+      def initialize(routes)
+        @routes = routes
+      end
+  
+      ##
+      # Compiles all routes into regexps.
+      #
+      def compile!
+        return if compiled?
+        @regexps = @routes.map.with_index do |route, index|
+          route.index = index
+          /(?<_#{index}>#{route.matcher.to_regexp})/
+        end
+        @regexps = recursive_compile(@regexps)
+        @compiled = true
+      end
+
+      ##
+      # Returns true if all routes has been compiled.
+      #
+      def compiled?
+        !!@compiled
+      end
+
+      ##
+      # Finds routes by using request or env.
+      #
+      def find_by(request_or_env)
+        request = request_or_env.is_a?(Hash) ? Sinatra::Request.new(request_or_env) : request_or_env
+        pattern = encode_default_external(request.path_info)
+        verb    = request.request_method
+        rotation { |offset| match?(offset, pattern) }.select { |route| route.verb == verb }
+      end
+
+      ##
+      # Calls routes by using request.
+      #
+      def call_by_request(request)
+        rotation do |offset|
+          pattern  = encode_default_external(request.path_info)
+          if route = match?(offset, pattern)
+            params = route.params_for(pattern, request.params)
+            yield(route, params) if route.verb == request.request_method
+            route
+          end
+        end
+      end
+
+      ##
+      # Finds routes by using PATH_INFO.
+      #
+      def find_by_pattern(pattern)
+        pattern = pattern.encode(Encoding.default_external)
+        rotation { |offset| match?(offset, pattern) }
+      end
+  
+      private
+
+      ##
+      # Returns a instance of PathRouter::Route if path is matched with current regexp
+      #
+      def match?(offset, path)
+        current_regexp = @regexps[offset]
+        return unless current_regexp === path || current_regexp === path[0..-2]
+        @routes[offset..-1].detect{ |route| Regexp.last_match["_#{route.index}"] }
+      end
+
+      ##
+      # Runs through all regexps to find routes.
+      #
+      def rotation(offset = 0)
+        compile! unless compiled?
+        loop.with_object([]) do |_, candidacies|
+          return candidacies unless route = yield(offset)
+          candidacies << route
+          offset = route.index.next
+        end
+      end
+
+      ##
+      # Compiles routes into regexp recursively.
+      #
+      def recursive_compile(regexps, paths = [])
+        return paths if regexps.length.zero?
+        paths << Regexp.union(regexps)
+        regexps.shift
+        recursive_compile(regexps, paths)
+      end
+
+      ##
+      # Encode string with Encoding.default_external
+      #
+      def encode_default_external(string)
+        string.encode(Encoding.default_external)
+      end
+    end
+  end
+end

data/lib/tennpipes-base/path_router/error_handler.rb

@@ -0,0 +1,8 @@
+module Tennpipes
+  module PathRouter
+    ##
+    # @see PathRouter::Router#path
+    #
+    InvalidRouteException = Class.new(ArgumentError)
+  end
+end

data/lib/tennpipes-base/path_router/matcher.rb

@@ -0,0 +1,123 @@
+require 'mustermann/sinatra'
+
+module Tennpipes
+  module PathRouter
+    class Matcher
+      # To count group of regexp
+      GROUP_REGEXP = %r{\((?!\?:|\?!|\?<=|\?<!|\?=).+?\)}.freeze
+
+      ##
+      # Constructs an instance of PathRouter::Matcher.
+      #
+      def initialize(path, options = {})
+        @path = path.is_a?(String) && path.empty? ? "/" : path
+        @capture = options[:capture]
+        @default_values = options[:default_values]
+      end
+  
+      ##
+      # Matches a pattern with the route matcher.
+      #
+      def match(pattern)
+        if match_data = handler.match(pattern)
+          match_data
+        elsif mustermann? && pattern != "/" && pattern.end_with?("/")
+          handler.match(pattern[0..-2])
+        end
+      end
+
+      ##
+      # Returns a regexp from handler.
+      #
+      def to_regexp
+        mustermann? ? handler.to_regexp : handler
+      end
+  
+      ##
+      # Expands the path by using parameters.
+      #
+      def expand(params)
+        params = params.merge(@default_values) if @default_values.is_a?(Hash)
+        expanded_path = handler.expand(:append, params)
+        expanded_path
+      end
+  
+      ##
+      # Returns true if handler is an instance of Mustermann.
+      #
+      def mustermann?
+        handler.instance_of?(Mustermann::Sinatra)
+      end
+
+      ##
+      # Builds a parameters, and returns them.
+      #
+      def params_for(pattern, others)
+        data = match(pattern)
+        params = indifferent_hash
+        if data.names.empty?
+          params.merge!(:captures => data.captures) unless data.captures.empty?
+        else
+          if mustermann?
+            new_params = handler.params(pattern, :captures => data)
+            params.merge!(new_params) if new_params
+          elsif data
+            params.merge!(Hash[names.zip(data.captures)])
+          end
+          params.merge!(others){ |_, old, new| old || new }
+        end
+        params
+      end
+  
+      ##
+      # Returns the handler which is an instance of Mustermann or Regexp.
+      #
+      def handler
+        @handler ||=
+          case @path
+          when String
+            Mustermann.new(@path, :capture => @capture)
+          when Regexp
+            /^(?:#{@path})$/
+          else
+            @path
+          end
+      end
+  
+      ##
+      # Converts the handler into string.
+      #
+      def to_s
+        handler.to_s
+      end
+  
+      ##
+      # Returns names of the handler.
+      # @see Regexp#names
+      #
+      def names
+        handler.names
+      end
+
+      ##
+      # Returns captures parameter length.
+      #
+      def capture_length
+        if mustermann?
+          handler.named_captures.inject(0) { |count, (_, capture)| count += capture.length }
+        else
+          handler.inspect.scan(GROUP_REGEXP).length
+        end
+      end
+
+      private
+
+      ##
+      # Creates a hash with indifferent access.
+      #
+      def indifferent_hash
+        Hash.new{ |hash, key| hash[key.to_s] if key.instance_of?(Symbol) }
+      end
+    end
+  end
+end

data/lib/tennpipes-base/path_router/route.rb

@@ -0,0 +1,169 @@
+module Tennpipes
+  module PathRouter
+    class Route
+      ##
+      # The accessors are useful to access from PathRouter::Router
+      #
+      attr_accessor :name, :capture, :order, :options, :index
+
+      ##
+      # A reader for compile option
+      #
+      attr_reader :verb, :block
+
+      ##
+      # The router will be treated in this class
+      #
+      attr_writer :router
+
+      ##
+      # The accessors will be used in other classes
+      #
+      attr_accessor :action, :cache, :cache_key, :cache_expires,
+                    :parent, :use_layout, :controller, :user_agent, :path_for_generation, :default_values
+  
+      ##
+      # Constructs an instance of PathRouter::Route.
+      #
+      def initialize(path, verb, options = {}, &block)
+        @path = path
+        @verb = verb
+        @capture = {}
+        @order   = 0
+        @block   = block if block_given?
+        merge_with_options!(options)
+      end
+  
+      ##
+      # Calls the route block with arguments.
+      #
+      def call(app, *args)
+        @block.call(app, *args)
+      end
+  
+      ##
+      # Returns the route's verb as an array.
+      #
+      def request_methods
+        [verb.to_s.upcase]
+      end
+  
+      ##
+      # Returns the original path.
+      #
+      def original_path
+        @path
+      end
+  
+      SIGNIFICANT_VARIABLES_REGEX = /(^|[^\\])[:\*]([a-zA-Z0-9_]+)/.freeze
+
+      ##
+      # Returns signficant variable names.
+      #
+      def significant_variable_names
+        @significant_variable_names ||=
+          if @path.is_a?(String)
+            @path.scan(SIGNIFICANT_VARIABLES_REGEX).map{ |p| p.last.to_sym }
+          elsif @path.is_a?(Regexp) and @path.respond_to?(:named_captures)
+            @path.named_captures.keys.map(&:to_sym)
+          else
+            []
+          end
+      end
+  
+      ##
+      # Returns an instance of PathRouter::Matcher that is associated with the route.
+      #
+      def matcher
+        @matcher ||= Matcher.new(@path, :capture => @capture, :default_values => default_values)
+      end
+
+      ##
+      # @see PathRouter::Matcher#match
+      #
+      def match(pattern)
+        matcher.match(pattern)
+      end
+  
+      ##
+      # Associates a block with the route, and increments current order of the router.
+      #
+      def to(&block)
+        @block = block if block_given?
+        @order = @router.current_order
+        @router.increment_order
+      end
+  
+      ##
+      # Expands the path by using parameters.
+      # @see PathRouter::Matcher#expand
+      #
+      def path(*args)
+        return @path if args.empty?
+        params = args[0].dup
+        params.delete(:captures)
+        matcher.expand(params) if matcher.mustermann?
+      end
+
+      ##
+      # Returns parameters which is created by the matcher.
+      #
+      def params_for(pattern, others = {})
+        matcher.params_for(pattern, others)
+      end
+  
+      ##
+      # Returns before_filters as an array.
+      #
+      def before_filters(&block)
+        @_before_filters ||= []
+        @_before_filters << block if block_given?
+        @_before_filters
+      end
+
+      ##
+      # Returns after_filters as an array.
+      #
+      def after_filters(&block)
+        @_after_filters ||= []
+        @_after_filters << block if block_given?
+        @_after_filters
+      end
+  
+      ##
+      # Returns custom_conditions as an array.
+      #
+      def custom_conditions(&block)
+        @_custom_conditions ||= []
+        @_custom_conditions << block if block_given?
+        @_custom_conditions
+      end
+
+      ##
+      # Returns block parameter length.
+      #
+      def block_parameter_length
+        matcher.capture_length
+      end
+
+      private
+  
+      ##
+      # Set value to accessor if option name has been defined as an accessora.
+      #
+      def merge_with_options!(options)
+        @options ||= {}
+        options.each_pair do |key, value|
+          accessor?(key) ? __send__("#{key}=", value) : (@options[key] = value)
+        end
+      end
+  
+      ##
+      # Returns true if name has been defined as an accessor.
+      #
+      def accessor?(key)
+        respond_to?("#{key}=") && respond_to?(key)
+      end
+    end
+  end
+end

data/lib/tennpipes-base/reloader.rb

@@ -0,0 +1,309 @@
+require 'pathname'
+require 'tennpipes-base/reloader/rack'
+require 'tennpipes-base/reloader/storage'
+
+module Tennpipes
+  ##
+  # High performance source code reloader middleware
+  #
+  module Reloader
+    ##
+    # This reloader is suited for use in a many environments because each file
+    # will only be checked once and only one system call to stat(2) is made.
+    #
+    # Please note that this will not reload files in the background, and does so
+    # only when explicitly invoked.
+    #
+    extend self
+
+    # The modification times for every file in a project.
+    MTIMES = {}
+
+    ##
+    # Specified folders can be excluded from the code reload detection process.
+    # Default excluded directories at Tennpipes.root are: test, spec, features, tmp, config, db and public
+    #
+    def exclude
+      @_exclude ||= Set.new %w(test spec tmp features config public db).map{ |path| Tennpipes.root(path) }
+    end
+
+    ##
+    # Specified constants can be excluded from the code unloading process.
+    #
+    def exclude_constants
+      @_exclude_constants ||= Set.new
+    end
+
+    ##
+    # Specified constants can be configured to be reloaded on every request.
+    # Default included constants are: [none]
+    #
+    def include_constants
+      @_include_constants ||= Set.new
+    end
+
+    ##
+    # Reload apps and files with changes detected.
+    #
+    def reload!
+      rotation do |file|
+        next unless file_changed?(file)
+        reload_special(file) || reload_regular(file)
+      end
+    end
+
+    ##
+    # Remove files and classes loaded with stat
+    #
+    def clear!
+      MTIMES.clear
+      Storage.clear!
+    end
+
+    ##
+    # Returns true if any file changes are detected.
+    #
+    def changed?
+      rotation do |file|
+        break true if file_changed?(file)
+      end
+    end
+
+    ##
+    # We lock dependencies sets to prevent reloading of protected constants
+    #
+    def lock!
+      klasses = ObjectSpace.classes do |klass|
+        klass._orig_klass_name.split('::').first
+      end
+      klasses |= Tennpipes.mounted_apps.map(&:app_class)
+      exclude_constants.merge(klasses)
+    end
+
+    ##
+    # A safe Kernel::require which issues the necessary hooks depending on results
+    #
+    def safe_load(file, options={})
+      began_at = Time.now
+      file     = figure_path(file)
+      return unless options[:force] || file_changed?(file)
+      return require(file) if feature_excluded?(file)
+
+      Storage.prepare(file) # might call #safe_load recursively
+      logger.devel(file_new?(file) ? :loading : :reload, began_at, file)
+      begin
+        with_silence{ require(file) }
+        Storage.commit(file)
+        update_modification_time(file)
+      rescue Exception => exception
+        unless options[:cyclic]
+          logger.exception exception, :short
+          logger.error "Failed to load #{file}; removing partially defined constants"
+        end
+        Storage.rollback(file)
+        raise
+      end
+    end
+
+    ##
+    # Removes the specified class and constant.
+    #
+    def remove_constant(const)
+      return if constant_excluded?(const)
+      base, _, object = const.to_s.rpartition('::')
+      base = base.empty? ? Object : base.constantize
+      base.send :remove_const, object
+      logger.devel "Removed constant #{const} from #{base}"
+    rescue NameError
+    end
+
+    ##
+    # Remove a feature from $LOADED_FEATURES so it can be required again.
+    #
+    def remove_feature(file)
+      $LOADED_FEATURES.delete(file) unless feature_excluded?(file)
+    end
+
+    ##
+    # Returns the list of special tracked files for Reloader.
+    #
+    def special_files
+      @special_files ||= Set.new
+    end
+
+    ##
+    # Sets the list of special tracked files for Reloader.
+    #
+    def special_files=(files)
+      @special_files = Set.new(files)
+    end
+
+    private
+
+    ##
+    # Returns absolute path of the file.
+    #
+    def figure_path(file)
+      return file if Pathname.new(file).absolute?
+      $LOAD_PATH.each do |path|
+        found = File.join(path, file)
+        return File.expand_path(found) if File.file?(found)
+      end
+      file
+    end
+
+    ##
+    # Reloads the file if it's special. For now it's only I18n locale files.
+    #
+    def reload_special(file)
+      return unless special_files.any?{ |special_file| File.identical?(special_file, file) }
+      if defined?(I18n)
+        began_at = Time.now
+        I18n.reload!
+        update_modification_time(file)
+        logger.devel :reload, began_at, file
+      end
+      true
+    end
+
+    ##
+    # Reloads ruby file and applications dependent on it.
+    #
+    def reload_regular(file)
+      apps = mounted_apps_of(file)
+      if apps.empty?
+        reloadable_apps.each do |app|
+          app.app_obj.reload! if app.app_obj.dependencies.include?(file)
+        end
+        safe_load(file)
+      else
+        apps.each { |app| app.app_obj.reload! }
+        update_modification_time(file)
+      end
+    end
+
+    ###
+    # Macro for mtime update.
+    #
+    def update_modification_time(file)
+      MTIMES[file] = File.mtime(file)
+    end
+
+    ###
+    # Returns true if the file is new or it's modification time changed.
+    #
+    def file_changed?(file)
+      file_new?(file) || File.mtime(file) > MTIMES[file]
+    end
+
+    ###
+    # Returns true if the file is new.
+    #
+    def file_new?(file)
+      MTIMES[file].nil?
+    end
+
+    ##
+    # Searches Ruby files in your +Tennpipes.load_paths+ , Tennpipes::Application.load_paths
+    # and monitors them for any changes.
+    #
+    def rotation
+      files_for_rotation.each do |file|
+        file = File.expand_path(file)
+        next if Reloader.exclude.any? { |base| file.start_with?(base) } || !File.file?(file)
+        yield file
+      end
+      nil
+    end
+
+    ##
+    # Creates an array of paths for use in #rotation.
+    #
+    def files_for_rotation
+      files = Set.new
+      files += Dir.glob("#{Tennpipes.root}/{lib,models,shared}/**/*.rb")
+      reloadable_apps.each do |app|
+        files << app.app_file
+        files += Dir.glob(app.app_obj.prerequisites)
+        files += app.app_obj.dependencies
+      end
+      files + special_files
+    end
+
+    ##
+    # Tells if a feature should be excluded from Reloader tracking.
+    #
+    def feature_excluded?(file)
+      !file.start_with?(Tennpipes.root) || exclude.any?{ |excluded_path| file.start_with?(excluded_path) }
+    end
+
+    ##
+    # Tells if a constant should be excluded from Reloader routines.
+    #
+    def constant_excluded?(const)
+      external_constant?(const) || (exclude_constants - include_constants).any?{ |excluded_constant| const._orig_klass_name.start_with?(excluded_constant) }
+    end
+
+    ##
+    # Tells if a constant is defined only outside of Tennpipes project path.
+    # If a constant has any methods defined inside of the project path it's
+    # considered internal and will be included in further testing.
+    #
+    def external_constant?(const)
+      sources = object_sources(const)
+      begin
+        if sample = ObjectSpace.each_object(const).first
+          sources += object_sources(sample)
+        end
+      rescue RuntimeError => error # JRuby 1.7.12 fails to ObjectSpace.each_object
+        raise unless RUBY_PLATFORM =='java' && error.message.start_with?("ObjectSpace is disabled")
+      end
+      !sources.any?{ |source| source.start_with?(Tennpipes.root) }
+    end
+
+    ##
+    # Gets all the sources in which target's class or instance methods are defined.
+    #
+    # Note: Method#source_location is for Ruby 1.9.3+ only.
+    #
+    def object_sources(target)
+      sources = Set.new
+      target.methods.each do |method_name|
+        next unless method_name.kind_of?(Symbol)
+        method_object = target.method(method_name)
+        if method_object.owner == (target.class == Class ? target.singleton_class : target.class)
+          sources << method_object.source_location.first
+        end
+      end
+      sources
+    end
+
+    ##
+    # Return the mounted_apps providing the app location.
+    # Can be an array because in one app.rb we can define multiple Tennpipes::Application.
+    #
+    def mounted_apps_of(file)
+      Tennpipes.mounted_apps.select { |app| File.identical?(file, app.app_file) }
+    end
+
+    ##
+    # Return the apps that allow reloading.
+    #
+    def reloadable_apps
+      Tennpipes.mounted_apps.select do |app|
+        next unless app.app_file.start_with?(Tennpipes.root)
+        app.app_obj.respond_to?(:reload) && app.app_obj.reload?
+      end
+    end
+
+    ##
+    # Disables output, yields block, switches output back.
+    #
+    def with_silence
+      verbosity_level, $-v = $-v, nil
+      yield
+    ensure
+      $-v = verbosity_level
+    end
+  end
+end