trinidad 1.4.6 → 1.5.0.B1

data/lib/trinidad/version.rb

@@ -1,3 +1,3 @@
 module Trinidad
-  VERSION = '1.4.6'
+  VERSION = '1.5.0.B1'
 end

data/lib/trinidad/web_app.rb

@@ -63,23 +63,25 @@ module Trinidad
     def jruby_min_runtimes
       if min = config[:jruby_min_runtimes]
         return min.to_i # min specified overrides :threadsafe
-      else # but :threadsafe takes precendence over default :
-        self[:threadsafe] ? 1 : fetch_default_config_value(:jruby_min_runtimes)
+      else # but :threadsafe takes precedence over default
+        # (if no default value specified we'll end up thread-safe) :
+        self[:threadsafe] ? 1 : fetch_default_config_value(:jruby_min_runtimes, 1)
       end
     end
 
     def jruby_max_runtimes
       if max = config[:jruby_max_runtimes]
         return max.to_i # max specified overrides :threadsafe
-      else # but :threadsafe takes precendence over default :
-        self[:threadsafe] ? 1 : fetch_default_config_value(:jruby_max_runtimes)
+      else # but :threadsafe takes precedence over default
+        # (if no default value specified we'll end up thread-safe) :
+        self[:threadsafe] ? 1 : fetch_default_config_value(:jruby_max_runtimes, 1)
       end
     end
 
     def jruby_initial_runtimes
       if ini = config[:jruby_initial_runtimes]
         return ini.to_i # min specified overrides :threadsafe
-      else # but :threadsafe takes precendence over default :
+      else # but :threadsafe takes precedence over default :
         self[:threadsafe] ? 1 :
           fetch_default_config_value(:jruby_initial_runtimes, jruby_min_runtimes)
       end
@@ -131,24 +133,30 @@ module Trinidad
     def default_web_xml; self[:default_web_xml]; end
 
     def java_lib
-      # accepts #deprecated :libs_dir syntax
-      self[:java_lib] || self[:libs_dir] || @@defaults[:java_lib]
+      self[:java_lib] || begin
+        if libs_dir = self[:libs_dir] # @deprecated
+          Helpers.deprecate "please use :java_lib instead of :libs_dir"
+        end
+        libs_dir || @@defaults[:java_lib]
+      end
     end
 
     def java_classes
-      # accepts #deprecated :classes_dir syntax
-      self[:java_classes] || self[:classes_dir] || File.join(java_lib, 'classes')
+      self[:java_classes] || begin
+        if classes_dir = self[:classes_dir] # @deprecated
+          Helpers.deprecate "please use :java_classes instead of :classes_dir"
+        end
+        classes_dir || File.join(java_lib, 'classes')
+      end
     end
 
     def java_lib_dir
       @java_lib_dir ||= self[:java_lib_dir] || expand_path(java_lib)
     end
-    alias_method :libs_dir, :java_lib_dir # #deprecated
 
     def java_classes_dir
       @java_classes_dir ||= self[:java_classes_dir] || expand_path(java_classes)
     end
-    alias_method :classes_dir, :java_classes_dir # #deprecated
 
     def extensions
       @extensions ||= begin
@@ -161,11 +169,14 @@ module Trinidad
       @context_params ||= {}
       add_context_param 'jruby.min.runtimes', jruby_min_runtimes
       add_context_param 'jruby.max.runtimes', jruby_max_runtimes
-      add_context_param 'jruby.initial.runtimes', jruby_initial_runtimes
-      add_context_param 'jruby.runtime.acquire.timeout', jruby_runtime_acquire_timeout
+      unless threadsafe?
+        add_context_param 'jruby.initial.runtimes', jruby_initial_runtimes
+        add_context_param 'jruby.runtime.acquire.timeout', jruby_runtime_acquire_timeout
+      end
       add_context_param 'jruby.compat.version', jruby_compat_version
       add_context_param 'public.root', public_root
       add_context_param 'jruby.rack.layout_class', layout_class
+      # JRuby::Rack::ErrorApp got a bit smarter so use it, TODO maybe override ?
       add_context_param 'jruby.rack.error', false # do not start error app on errors
       @context_params
     end
@@ -220,10 +231,9 @@ module Trinidad
     #   cache: true
     #   cache_ttl: 60000
     def public_config
-      @public_config ||=
-        self[:public].is_a?(String) ?
-          { :root => self[:public] } :
-            ( self[:public] || {} )
+      @public_config ||= begin; public = self[:public]
+        public.is_a?(String) ? { :root => public } : ( public || {} )
+      end
     end
 
     def aliases # :public => { :aliases => ... }
@@ -268,17 +278,6 @@ module Trinidad
       self[:cache_ttl] || public_config[:cache_ttl]
     end
 
-    def class_loader
-      @class_loader ||=
-        org.jruby.util.JRubyClassLoader.new(JRuby.runtime.jruby_class_loader)
-    end
-
-    def class_loader!
-      ( @class_loader = nil ) || class_loader
-    end
-    # @deprecated replaced with {#class_loader!}
-    def generate_class_loader; class_loader!; end
-
     def define_lifecycle
       Lifecycle::WebApp::Default.new(self)
     end
@@ -420,8 +419,25 @@ module Trinidad
       config[:root_dir] ||= self.class.root_dir(config, default_config)
       config[:root_dir] = File.expand_path(config[:root_dir])
       config[:context_path] = self.class.context_path(config, default_config)
+
+      return if key?(:jruby_max_runtimes) || key?(:jruby_min_runtimes)
+
+      if ( ! key?(:threadsafe) && ! detect_threadsafe? ) || self[:threadsafe] == false
+        max_runtimes = config[:jruby_max_runtimes] = guess_max_runtimes
+        if environment == 'development' || environment == 'test'
+          config[:jruby_min_runtimes] = 1
+        else
+          config[:jruby_min_runtimes] = max_runtimes
+        end
+      else
+        config[:jruby_min_runtimes] = config[:jruby_max_runtimes] = 1
+      end
     end
 
+    def detect_threadsafe?(environment = self.environment); true end
+
+    def guess_max_runtimes; 5 end
+
     public
 
     # Returns true if there's a servlet with the given servlet-class name
@@ -511,7 +527,7 @@ module Trinidad
       value = default_config[name]
       if value.nil?
         # JRuby-Rack names: jruby_min_runtimes -> jruby.min.runtimes :
-        value = java.lang.System.getProperty(name.to_s.gsub('_', '.'))
+        value = ENV_JAVA[ name.to_s.gsub('_', '.') ]
         value ||= default
       end
       value
@@ -521,74 +537,76 @@ module Trinidad
       @logger ||= Logging::LogFactory.getLog('')
     end
 
-    protected
+    class << self
 
-    def self.rackup?(config, default_config = nil)
-      return true if config.has_key?(:rackup)
-      root_dir = root_dir(config, default_config)
-      config_ru = (default_config && default_config[:rackup]) || 'config.ru'
-      # check for rackup (but still use config/environment.rb for rails 3)
-      if File.exists?(File.join(root_dir, config_ru)) &&
-          ! rails?(config, default_config) # do not :rackup a rails app
-        config[:rackup] = config_ru
-      end
-      config[:rackup] || ! Dir[File.join(root_dir, 'WEB-INF/**/config.ru')].empty?
-    end
-
-    def self.rails?(config, default_config = nil)
-      root_dir = root_dir(config, default_config)
-      # standart Rails 3.x `class Application < Rails::Application`
-      if File.exists?(application = File.join(root_dir, 'config/application.rb'))
-        return true if file_line_match?(application, /^[^#]*Rails::Application/)
-      end
-      if File.exists?(environment = File.join(root_dir, 'config/environment.rb'))
-        return true if file_line_match?(environment) do |line|
-          # customized Rails 3.x, expects a `Rails::Application` subclass
-          # or a plain-old Rails 2.3 with `RAILS_GEM_VERSION = '2.3.14'`
-          line =~ /^[^#]*Rails::Application/ || line =~ /^[^#]*RAILS_GEM_VERSION/
+      def rackup?(config, default_config = nil)
+        return true if config.has_key?(:rackup)
+        root_dir = root_dir(config, default_config)
+        config_ru = (default_config && default_config[:rackup]) || 'config.ru'
+        # check for rackup (but still use config/environment.rb for rails 3)
+        if File.exists?(File.join(root_dir, config_ru)) &&
+            ! rails?(config, default_config) # do not :rackup a rails app
+          config[:rackup] = config_ru
         end
+        config[:rackup] || ! Dir[File.join(root_dir, 'WEB-INF/**/config.ru')].empty?
       end
-      false
-    end
 
-    def self.war?(config, default_config = nil)
-      root_dir = root_dir(config, default_config)
-      return true if root_dir && root_dir.to_s[-4..-1] == '.war'
-      context_path = config[:context_path] # backwards-compatibility :
-      context_path && context_path.to_s[-4..-1] == '.war'
-    end
+      def rails?(config, default_config = nil)
+        root_dir = root_dir(config, default_config)
+        # standard Rails 3.x/4.x `class Application < Rails::Application`
+        if File.exists?(application = File.join(root_dir, 'config/application.rb'))
+          return true if file_line_match?(application, /^[^#]*Rails::Application/)
+        end
+        if File.exists?(environment = File.join(root_dir, 'config/environment.rb'))
+          return true if file_line_match?(environment) do |line|
+            # customized Rails >= 3.x, expects a `Rails::Application` subclass
+            # or a plain-old Rails 2.3 with `RAILS_GEM_VERSION = '2.3.14'`
+            line =~ /^[^#]*Rails::Application/ || line =~ /^[^#]*RAILS_GEM_VERSION/
+          end
+        end
+        false
+      end
 
-    private
+      def war?(config, default_config = nil)
+        root_dir = root_dir(config, default_config)
+        return true if root_dir && root_dir.to_s[-4..-1] == '.war'
+        context_path = config[:context_path] # backwards-compatibility :
+        context_path && context_path.to_s[-4..-1] == '.war'
+      end
 
-    def self.root_dir(config, default_config, default_dir = Dir.pwd)
-      # for backwards compatibility accepts the :web_app_dir "alias"
-      config[:root_dir] || config[:web_app_dir] ||
-        ( default_config &&
-          ( default_config[:root_dir] || default_config[:web_app_dir] ) ) ||
-            default_dir
-    end
+      def root_dir(config, default_config, default_dir = Dir.pwd)
+        # for backwards compatibility accepts the :web_app_dir "alias"
+        config[:root_dir] || config[:web_app_dir] ||
+          ( default_config &&
+            ( default_config[:root_dir] || default_config[:web_app_dir] ) ) ||
+              default_dir
+      end
 
-    def self.context_path(config, default_config = nil)
-      path = config[:context_path] ||
-        ( default_config && default_config[:context_path] )
-      unless path
-        name = config[:context_name] ||
-          ( default_config && default_config[:context_name] )
-        path = name.to_s == 'default' ? '/' : "/#{name}"
+      def context_path(config, default_config = nil)
+        path = config[:context_path] ||
+          ( default_config && default_config[:context_path] )
+        unless path
+          name = config[:context_name] ||
+            ( default_config && default_config[:context_name] )
+          path = name.to_s == 'default' ? '/' : "/#{name}"
+        end
+        path = "/#{path}" if path.to_s[0, 1] != '/'
+        path.to_s
       end
-      path = "/#{path}" if path.to_s[0, 1] != '/'
-      path.to_s
-    end
 
-    def self.file_line_match?(path, pattern = nil)
-      File.open(path) do |file|
-        if block_given?
-          file.each_line { |line| return true if yield(line) }
-        else
-          file.each_line { |line| return true if line =~ pattern }
+      private
+
+      def file_line_match?(path, pattern = nil)
+        File.open(path) do |file|
+          if block_given?
+            file.each_line { |line| return true if yield(line) }
+          else
+            file.each_line { |line| return true if line =~ pattern }
+          end
         end
+        false
       end
-      false
+
     end
 
     class Holder
@@ -612,36 +630,6 @@ module Trinidad
       def lock; @lock = true; end
       def unlock; @lock = false; end
 
-      # #deprecated behaves Hash like for (<= 1.3.5) compatibility
-      def [](key)
-        case key.to_sym
-          when :app then
-            web_app
-          when :context then
-            context
-          when :lock then
-            @lock
-          when :monitor then
-            monitor
-          when :mtime then
-            monitor_mtime
-          else raise NoMethodError, key.to_s
-        end
-      end
-
-      # #deprecated behaves Hash like for (<= 1.3.5) compatibility
-      def []=(key, val)
-        case key.to_sym
-          when :context then
-            self.context=(val)
-          when :lock then
-            @lock = val
-          when :mtime then
-            self.monitor_mtime=(val)
-          else raise NoMethodError, "#{key}="
-        end
-      end
-
     end
 
   end
@@ -681,21 +669,42 @@ module Trinidad
 
     protected
 
-    def complete_config!
-      super
-      # detect threadsafe! in config/environments/environment.rb :
-      if ! key?(:threadsafe) && self.class.threadsafe?(root_dir, environment)
-        config[:jruby_min_runtimes] = 1 unless key?(:jruby_min_runtimes, false)
-        config[:jruby_max_runtimes] = 1 unless key?(:jruby_max_runtimes, false)
+    # NOTE: maybe we can guess these based on connector maxThreads?
+    # def guess_max_runtimes; 5 end
+
+    def detect_threadsafe?(environment = self.environment)
+      if environment == 'development' || environment == 'test'
+        # NOTE: it's best for development/test to use the same setup as in
+        # production by default, thread-safe likely won't be detected as :
+        #
+        #  __environments/development.rb__
+        #
+        #  # In the development environment your application's code is reloaded on
+        #  # every request. This slows down response time but is perfect for development
+        #  # since you don't have to restart the web server when you make code changes.
+        #  config.cache_classes = false
+        #
+        #  # Do not eager load code on boot.
+        #  config.eager_load = false
+        #
+        #  __environments/test.rb__
+        #
+        #  # The test environment is used exclusively to run your application's
+        #  # test suite. You never need to work with it otherwise. Remember that
+        #  # your test database is "scratch space" for the test suite and is wiped
+        #  # and recreated between test runs. Don't rely on the data there!
+        #  config.cache_classes = true
+        #
+        #  # Do not eager load code on boot. This avoids loading your whole application
+        #  # just for the purpose of running a single test. If you are using a tool that
+        #  # preloads Rails for running tests, you may have to set it to true.
+        #  config.eager_load = false
+        #
+        return self.class.threadsafe?(root_dir, 'production')
       end
+      self.class.threadsafe?(root_dir, environment)
     end
 
-    #def layout_class
-      #'JRuby::Rack::RailsFileSystemLayout'
-    #end
-
-    private
-
     def self.threadsafe?(app_base, environment)
       threadsafe_match?("#{app_base}/config/environments/#{environment}.rb") ||
         threadsafe_match?("#{app_base}/config/environment.rb")
@@ -703,7 +712,7 @@ module Trinidad
 
     def self.threadsafe_match?(file)
       File.exist?(file) && (
-        file_line_match?(file, /^[^#]*threadsafe!/) || ( # Rails 4.0
+        file_line_match?(file, /^[^#]*threadsafe!/) || ( # Rails 4.x
           file_line_match?(file, /^[^#]*config\.eager_load\s?*=\s?*true/) &&
           file_line_match?(file, /^[^#]*config\.cache_classes\s?*=\s?*true/)
         )
@@ -753,10 +762,6 @@ module Trinidad
       root_dir ? File.expand_path(root_dir) : nil # the .war file itself
     end
 
-    def class_loader
-      @class_loader ||= nil # lifecycle will setup JRuby CL
-    end
-
     def context_params
       warbler? ? super : @context_params ||= {}
     end

data/trinidad.gemspec

@@ -1,10 +1,10 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require 'trinidad/version'
 
 Gem::Specification.new do |gem|
   gem.name = 'trinidad'
-  gem.version = Trinidad::VERSION
+
+  path = File.expand_path("lib/trinidad/version.rb", File.dirname(__FILE__))
+  gem.version = File.read(path).match( /.*VERSION\s*=\s*['"](.*)['"]/m )[1]
 
   gem.summary = "Web server for Rails/Rack applications built upon JRuby::Rack and Apache Tomcat"
   gem.description = "Trinidad allows you to run Rails or Rack applications within " <<
@@ -22,13 +22,10 @@ Gem::Specification.new do |gem|
   gem.rdoc_options = ["--charset=UTF-8"]
   gem.extra_rdoc_files = %w[README.md LICENSE]
 
-  gem.add_dependency('trinidad_jars', '>= 1.3.0', '< 1.5.0')
-  gem.add_dependency('jruby-rack', '~> 1.1.13')
+  gem.add_dependency('trinidad_jars', '>= 1.4.0', '< 1.6.0')
+  gem.add_dependency('jruby-rack', '~> 1.1.14')
 
-  gem.add_development_dependency('rake')
   gem.add_development_dependency('rspec', '~> 2.14.1')
-  gem.add_development_dependency('mocha', '~> 0.12.1')
-  gem.add_development_dependency('fakefs', '>= 0.4.0')
 
   gem.files = `git ls-files`.split("\n").sort.
     reject { |file| file =~ /^\./ }. # .gitignore, .travis.yml

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trinidad
 version: !ruby/object:Gem::Version
-  version: 1.4.6
+  version: 1.5.0.B1
 platform: ruby
 authors:
 - David Calavera
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-12-28 00:00:00.000000000 Z
+date: 2014-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trinidad_jars
@@ -16,18 +16,18 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.4.0
     - - <
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.6.0
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.4.0
     - - <
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.6.0
   prerelease: false
   type: :runtime
 - !ruby/object:Gem::Dependency
@@ -36,28 +36,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.13
+        version: 1.1.14
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.13
+        version: 1.1.14
   prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: rake
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency
   name: rspec
   version_requirements: !ruby/object:Gem::Requirement
@@ -72,34 +58,6 @@ dependencies:
         version: 2.14.1
   prerelease: false
   type: :development
-- !ruby/object:Gem::Dependency
-  name: mocha
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.12.1
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.12.1
-  prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency
-  name: fakefs
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-  prerelease: false
-  type: :development
 description: Trinidad allows you to run Rails or Rack applications within an embedded Apache Tomcat container. Serves your requests with the elegance of a cat !
 email: calavera@apache.org
 executables:
@@ -117,7 +75,7 @@ files:
 - bin/trinidad
 - lib/rack/handler/trinidad.rb
 - lib/trinidad.rb
-- lib/trinidad/command_line_parser.rb
+- lib/trinidad/cli.rb
 - lib/trinidad/configuration.rb
 - lib/trinidad/extensions.rb
 - lib/trinidad/helpers.rb
@@ -151,12 +109,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.2.2
 signing_key:
 specification_version: 4
 summary: Web server for Rails/Rack applications built upon JRuby::Rack and Apache Tomcat