tennpipes-base 3.6.6

data/lib/tennpipes-base/reloader/rack.rb

@@ -0,0 +1,26 @@
+module Tennpipes
+  module Reloader
+    ##
+    # This class acts as a Rack middleware to be added to the application stack.
+    # This middleware performs a check and reload for source files at the start
+    # of each request, but also respects a specified cool down time
+    # during which no further action will be taken.
+    #
+    class Rack
+      def initialize(app, cooldown=1)
+        @app = app
+        @cooldown = cooldown
+        @last = (Time.now - cooldown)
+      end
+
+      # Invoked in order to perform the reload as part of the request stack.
+      def call(env)
+        if @cooldown && Time.now > @last + @cooldown
+          Thread.list.size > 1 ? Thread.exclusive { Tennpipes.reload! } : Tennpipes.reload!
+          @last = Time.now
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/tennpipes-base/reloader/storage.rb

@@ -0,0 +1,55 @@
+module Tennpipes
+  module Reloader
+    module Storage
+      extend self
+
+      def clear!
+        files.each_key do |file|
+          remove(file)
+          Reloader.remove_feature(file)
+        end
+        @files = {}
+      end
+
+      def remove(name)
+        file = files[name] || return
+        file[:constants].each{ |constant| Reloader.remove_constant(constant) }
+        file[:features].each{ |feature| Reloader.remove_feature(feature) }
+        files.delete(name)
+      end
+
+      def prepare(name)
+        file = remove(name)
+        @old_entries ||= {}
+        @old_entries[name] = {
+          :constants => ObjectSpace.classes,
+          :features  => old_features = Set.new($LOADED_FEATURES.dup)
+        }
+        features = file && file[:features] || []
+        features.each{ |feature| Reloader.safe_load(feature, :force => true) }
+        Reloader.remove_feature(name) if old_features.include?(name)
+      end
+
+      def commit(name)
+        entry = {
+          :constants => ObjectSpace.new_classes(@old_entries[name][:constants]),
+          :features  => Set.new($LOADED_FEATURES) - @old_entries[name][:features] - [name]
+        }
+        files[name] = entry
+        @old_entries.delete(name)
+      end
+
+      def rollback(name)
+        new_constants = ObjectSpace.new_classes(@old_entries[name][:constants])
+        new_constants.each{ |klass| Reloader.remove_constant(klass) }
+        @old_entries.delete(name)
+      end
+
+      private
+
+      def files
+        @files ||= {}
+      end
+    end
+  end
+end

data/lib/tennpipes-base/router.rb

@@ -0,0 +1,98 @@
+module Tennpipes
+  ##
+  # This class is an extended version of Rack::URLMap.
+  #
+  # Tennpipes::Router like Rack::URLMap dispatches in such a way that the
+  # longest paths are tried first, since they are most specific.
+  #
+  # Features:
+  #
+  # * Map a path to the specified App
+  # * Ignore server names (this solve issues with vhost and domain aliases)
+  # * Use hosts instead of server name for mappings (this help us with our vhost and domain aliases)
+  #
+  # @example
+  #
+  #   routes = Tennpipes::Router.new do
+  #     map(:path => "/", :to => TennpipesWeb, :host => "tennpipes.local")
+  #     map(:path => "/", :to => Admin, :host => "admin.tennpipes.local")
+  #   end
+  #   run routes
+  #
+  #   routes = Tennpipes::Router.new do
+  #     map(:path => "/", :to => TennpipesWeb, :host => /*.tennpipes.local/)
+  #   end
+  #   run routes
+  #
+  # @api semipublic
+  class Router
+    def initialize(*mapping, &block)
+      @mapping = []
+      mapping.each { |m| map(m) }
+      instance_eval(&block) if block
+    end
+
+    ##
+    # Map a route path and host to a specified application.
+    #
+    # @param [Hash] options
+    #  The options to map.
+    # @option options [Sinatra::Application] :to
+    #  The class of the application to mount.
+    # @option options [String] :path ("/")
+    #  The path to map the specified application.
+    # @option options [String] :host
+    #  The host to map the specified application.
+    #
+    # @example
+    #  map(:path => "/", :to => TennpipesWeb, :host => "tennpipes.local")
+    #
+    # @return [Array] The sorted route mappings.
+    # @api semipublic
+    def map(options={})
+      path = options[:path] || "/"
+      host = options[:host]
+      app  = options[:to]
+
+      raise ArgumentError, "paths need to start with /" if path[0] != ?/
+      raise ArgumentError, "app is required" if app.nil?
+
+      path  = path.chomp('/')
+      match = Regexp.new("^#{Regexp.quote(path).gsub('/', '/+')}(.*)", nil, 'n')
+      host  = Regexp.new("^#{Regexp.quote(host)}$", true, 'n') unless host.nil? || host.is_a?(Regexp)
+
+      @mapping << [host, path, match, app]
+    end
+
+    # The call handler setup to route a request given the mappings specified.
+    def call(env)
+      began_at = Time.now
+      path_info = env["PATH_INFO"].to_s
+      script_name = env['SCRIPT_NAME']
+      http_host = env['HTTP_HOST']
+      last_result = nil
+
+      @mapping.each do |host, path, match, app|
+        next unless host.nil? || http_host =~ host
+        next unless path_info =~ match && rest = $1
+        next unless rest.empty? || rest[0] == ?/
+
+        rest = "/" if rest.empty?
+
+        env['SCRIPT_NAME'] = script_name + path
+        env['PATH_INFO'] = rest
+        last_result = app.call(env)
+
+        cascade_setting = app.respond_to?(:cascade) ? app.cascade : true
+        cascade_statuses = cascade_setting.respond_to?(:include?) ? cascade_setting : Mounter::DEFAULT_CASCADE
+        break unless cascade_setting && cascade_statuses.include?(last_result[0])
+      end
+      last_result || begin
+        env['SCRIPT_NAME'] = script_name
+        env['PATH_INFO'] = path_info
+        Tennpipes::Logger::Rack.new(nil,'/').send(:log, env, 404, {}, began_at) if logger.debug?
+        [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path_info}"]]
+      end
+    end
+  end
+end

data/lib/tennpipes-base/server.rb

@@ -0,0 +1,119 @@
+module Tennpipes
+  ##
+  # Runs the Tennpipes apps as a self-hosted server using:
+  # thin, mongrel, or WEBrick in that order.
+  #
+  # @example
+  #   Tennpipes.run! # with these defaults => host: "127.0.0.1", port: "3000", adapter: the first found
+  #   Tennpipes.run!("0.0.0.0", "4000", "mongrel") # use => host: "0.0.0.0", port: "4000", adapter: "mongrel"
+  #
+  def self.run!(options={})
+    Tennpipes.load!
+    Server.start(*detect_application(options))
+  end
+
+  private
+
+  #
+  #
+  def self.detect_application(options)
+    default_config_file = 'config.ru'
+    if (config_file = options.delete(:config)) || File.file?(default_config_file)
+      config_file ||= default_config_file
+      fail "Rack config file `#{config_file}` must have `.ru` extension" unless config_file =~ /\.ru$/
+      rack_app, rack_options = Rack::Builder.parse_file(config_file)
+      [rack_app, rack_options.merge(options)]
+    else
+      [Tennpipes.application, options]
+    end
+  end
+
+  ##
+  # This module builds a Tennpipes server to run the project based on available handlers.
+  #
+  class Server < Rack::Server
+    DEFAULT_ADDRESS = { :Host => '127.0.0.1', :Port => 3000 }
+
+    # Server Handlers
+    Handlers = [:thin, :puma, :'spider-gazelle', :mongrel, :trinidad, :webrick]
+
+    # Starts the application on the available server with specified options.
+    def self.start(app, options={})
+      options = options.to_hash.symbolize_keys
+      options.update(parse_server_options(options.delete(:options)))
+      options.update(detect_address(options))
+      options[:pid] = prepare_pid(options[:pid]) if options[:daemonize]
+      options[:server] = detect_rack_handler if options[:server].blank?
+      # disable Webrick AccessLog
+      options[:AccessLog] = []
+      new(options, app).start
+    end
+
+    def initialize(options, app)
+      @options, @app = options, app
+    end
+
+    # Starts the application on the available server with specified options.
+    def start
+      puts "=> Tennpipes/#{Tennpipes.version} has taken the stage #{Tennpipes.env} at http://#{options[:Host]}:#{options[:Port]}"
+      [:INT, :TERM].each { |sig| trap(sig) { exit } }
+      super do |server|
+        server.threaded = true if server.respond_to?(:threaded=)
+      end
+    ensure
+      puts "<= Tennpipes leaves the gun, takes the cannoli" unless options[:daemonize]
+    end
+
+    # The application the server will run.
+    def app
+      @app
+    end
+    alias :wrapped_app :app
+
+    def options
+      @options
+    end
+
+    private
+
+    # Detects the supported handler to use.
+    #
+    # @example
+    #   detect_rack_handler => <ThinHandler>
+    #
+    def self.detect_rack_handler
+      Handlers.each do |handler|
+        begin
+          return handler if Rack::Handler.get(handler.to_s.downcase)
+        rescue LoadError
+        rescue NameError
+        end
+      end
+      fail "Server handler (#{Handlers.join(', ')}) not found."
+    end
+
+    # Prepares a directory for pid file.
+    #
+    def self.prepare_pid(pid)
+      pid = 'tmp/pids/server.pid' if pid.blank?
+      FileUtils.mkdir_p(File.dirname(pid))
+      File.expand_path(pid)
+    end
+
+    # Parses an array of server options.
+    #
+    def self.parse_server_options(options)
+      parsed_server_options = Array(options).flat_map{ |option| option.split('=', 2) }
+      Hash[*parsed_server_options].symbolize_keys
+    end
+
+    # Detects Host and Port for Rack server.
+    #
+    def self.detect_address(options)
+      address = DEFAULT_ADDRESS.merge options.slice(:Host, :Port)
+      address[:Host] = options[:host] if options[:host].present?
+      address[:Port] = options[:port] if options[:port].present?
+      address
+    end
+  end
+end

data/lib/tennpipes-base/tasks.rb

@@ -0,0 +1,21 @@
+module Tennpipes
+  ##
+  # This module it's used for bootstrap with tennpipes rake
+  # third party tasks, in your gem/plugin/extension you
+  # need only do this:
+  #
+  # @example
+  #   Tennpipes::Tasks.files << yourtask.rb
+  #   Tennpipes::Tasks.files.concat(Dir["/path/to/all/my/tasks/*.rb"])
+  #   Tennpipes::Tasks.files.unshift("yourtask.rb")
+  #
+  module Tasks
+
+    ##
+    # Returns a list of files to handle with tennpipes rake
+    #
+    def self.files
+      @files ||= []
+    end
+  end
+end

data/lib/tennpipes-base/version.rb

@@ -0,0 +1,20 @@
+#
+# Manages current Tennpipes version for use in gem generation.
+#
+# We put this in a separate file so you can get tennpipes version
+# without include full tennpipes core.
+#
+module Tennpipes
+  # The version constant for the current version of Tennpipes.
+  VERSION = '3.6.6' unless defined?(Tennpipes::VERSION)
+
+  #
+  # The current Tennpipes version.
+  #
+  # @return [String]
+  #   The version number.
+  #
+  def self.version
+    VERSION
+  end
+end # Tennpipes

data/lib/tennpipes-base/version.rb~

@@ -0,0 +1,20 @@
+#
+# Manages current Tennpipes version for use in gem generation.
+#
+# We put this in a separate file so you can get tennpipes version
+# without include full tennpipes core.
+#
+module Tennpipes
+  # The version constant for the current version of Tennpipes.
+  VERSION = '0.0.2' unless defined?(Tennpipes::VERSION)
+
+  #
+  # The current Tennpipes version.
+  #
+  # @return [String]
+  #   The version number.
+  #
+  def self.version
+    VERSION
+  end
+end # Tennpipes

data/test/fixtures/app_gem/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in app_gem.gemspec
+gemspec

data/test/fixtures/app_gem/app/app.rb

@@ -0,0 +1,3 @@
+class AppGem::App < Tennpipes::Application
+  set :version, AppGem::VERSION
+end

data/test/fixtures/app_gem/app_gem.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/app_gem/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Florian Gilcher"]
+  gem.email         = ["florian.gilcher@asquera.de"]
+  gem.description   = %q{TODO: Write a gem description}
+  gem.summary       = %q{TODO: Write a gem summary}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "app_gem"
+  gem.require_paths = ["app", "lib"]
+  gem.version       = AppGem::VERSION
+end

data/test/fixtures/app_gem/lib/app_gem.rb

@@ -0,0 +1,7 @@
+require 'tennpipes'
+
+module AppGem
+  extend Tennpipes::Module
+
+  gem! 'app_gem'
+end

data/test/fixtures/app_gem/lib/app_gem/version.rb

@@ -0,0 +1,3 @@
+module AppGem
+  VERSION = "0.0.1"
+end

data/test/fixtures/apps/complex.rb

@@ -0,0 +1,32 @@
+TENNPIPES_ROOT = File.dirname(__FILE__) unless defined? TENNPIPES_ROOT
+
+module LibDemo
+  def self.give_me_a_random
+    @rand ||= rand(100)
+  end
+end
+
+class Complex1Demo < Tennpipes::Application
+  set :reload, true
+  get("/old"){ "Old Sinatra Way" }
+end
+
+class Complex2Demo < Tennpipes::Application
+  set :reload, true
+  get("/old"){ "Old Sinatra Way" }
+
+  controllers :var do
+    get(:destroy){ params.inspect }
+  end
+
+  get("/"){ "The magick number is: 12!" } # Change only the number!!!
+end
+
+Complex1Demo.controllers do
+  get("/"){ "Given random #{LibDemo.give_me_a_random}" }
+end
+
+Complex2Demo.controllers do
+end
+
+Tennpipes.load!

data/test/fixtures/apps/demo_app.rb

@@ -0,0 +1,7 @@
+TENNPIPES_ROOT = File.dirname(__FILE__) unless defined? TENNPIPES_ROOT
+
+module Demo
+  class App < Tennpipes::Application
+    set :reload, true
+  end
+end