padrino-core 0.12.9 → 0.13.0.beta1

data/lib/padrino-core/cli/binstub.rb

@@ -1,27 +0,0 @@
-module Padrino
-  ##
-  # Replaces the current process with it's binstub.
-  #
-  def self.replace_with_binstub(executable)
-    begin
-      return if Bundler.definition.missing_specs.empty?
-    rescue NameError, NoMethodError, Bundler::GemfileNotFound
-    end
-
-    project_root = Dir.pwd
-    until project_root.empty?
-      break if File.file?(File.join(project_root, 'Gemfile'))
-      project_root = project_root.rpartition('/').first
-    end
-
-    if %w(Gemfile .components).all? { |file| File.file?(File.join(project_root, file)) }
-      binstub = File.join(project_root, 'bin', executable)
-      if File.file?(binstub)
-        exec Gem.ruby, binstub, *ARGV
-      else
-        puts 'Please run `bundler install --binstubs` from your project root to generate bundle-specific executables'
-        exit!
-      end
-    end
-  end
-end

data/lib/padrino-core/configuration.rb

@@ -1,40 +0,0 @@
-require 'ostruct'
-
-module Padrino
-  ##
-  # Padrino simple configuration module
-  #
-  module Configuration
-    ##
-    # Returns the configuration structure allowing to get and set it's values.
-    # Padrino.config is a simple Ruby OpenStruct object with no additional magic.
-    #
-    # Example:
-    #
-    #   Padrino.config.value1 = 42
-    #   exit if Padrino.config.exiting
-    #
-    def config
-      @config ||= OpenStruct.new
-    end
-
-    ##
-    # Allows to configure different environments differently. Requires a block.
-    #
-    # Example:
-    #
-    #   Padrino.configure :development do |config|
-    #     config.value2 = 'only development'
-    #   end
-    #   Padrino.configure :development, :production do |config|
-    #     config.value2 = 'both development and production'
-    #   end
-    #   Padrino.configure do |config|
-    #     config.value2 = 'any environment'
-    #   end
-    #
-    def configure(*environments)
-      yield(config) if environments.empty? || environments.include?(Padrino.env)
-    end
-  end
-end

data/lib/padrino-core/ext/http_router.rb

@@ -1,201 +0,0 @@
-require 'http_router' unless defined?(HttpRouter)
-
-class HttpRouter
-  def rewrite_partial_path_info(env, request); end
-  def rewrite_path_info(env, request); end
-
-  def process_destination_path(path, env)
-    Thread.current['padrino.instance'].instance_eval do
-      request.route_obj = path.route
-      @_response_buffer = nil
-      @route    = path.route
-      @params ||= {}
-      @params.update(env['router.params'])
-      @block_params = if match_data = env['router.request'].extra_env['router.regex_match']
-        params_list = match_data.to_a
-        params_list.shift
-        @params[:captures] = params_list
-        params_list
-      else
-        env['router.request'].params
-      end
-      # Provide access to the current controller to the request
-      # Now we can eval route, but because we have "throw halt" we need to be
-      # (en)sure to reset old layout and run controller after filters.
-      original_params = @params
-      parent_layout   = @layout
-      successful      = false
-      begin
-        filter! :before
-        (@route.before_filters - settings.filters[:before]).each { |block| instance_eval(&block) }
-        @layout = path.route.use_layout if path.route.use_layout
-        @route.custom_conditions.each { |block| pass if block.bind(self).call == false }
-        halt_response     = catch(:halt) { route_eval { @route.dest[self, @block_params] } }
-        @_response_buffer = halt_response.is_a?(Array) ? halt_response.last : halt_response
-        successful        = true
-        halt halt_response
-      ensure
-        (@route.after_filters - settings.filters[:after]).each { |block| instance_eval(&block) } if successful
-        @layout = parent_layout
-        @params = original_params
-      end
-    end
-  end
-
-  class Route
-    VALID_HTTP_VERBS.replace %w[GET POST PUT PATCH DELETE HEAD OPTIONS LINK UNLINK]
-
-    attr_accessor :use_layout, :controller, :action, :cache, :cache_key, :cache_expires, :parent
-
-    def before_filters(&block)
-      @_before_filters ||= []
-      @_before_filters << block if block_given?
-
-      @_before_filters
-    end
-
-    def after_filters(&block)
-      @_after_filters ||= []
-      @_after_filters << block if block_given?
-
-      @_after_filters
-    end
-
-    def custom_conditions(&block)
-      @_custom_conditions ||= []
-      @_custom_conditions << block if block_given?
-
-      @_custom_conditions
-    end
-
-    def significant_variable_names
-      @significant_variable_names ||= if @original_path.is_a?(String)
-        @original_path.scan(/(^|[^\\])[:\*]([a-zA-Z0-9_]+)/).map{|p| p.last.to_sym}
-      elsif @original_path.is_a?(Regexp) and @original_path.respond_to?(:named_captures)
-        @original_path.named_captures.keys.map(&:to_sym)
-      else
-        []
-      end
-    end
-
-    def to(dest = nil, &dest_block)
-      @dest = dest || dest_block || raise("you didn't specify a destination")
-
-      @router.current_order ||= 0
-      @order = @router.current_order
-      @router.current_order += 1
-
-      if @dest.respond_to?(:url_mount=)
-        urlmount = UrlMount.new(@path_for_generation, @default_values || {}) # TODO url mount should accept nil here.
-        urlmount.url_mount = @router.url_mount if @router.url_mount
-        @dest.url_mount = urlmount
-      end
-      self
-    end
-
-    attr_accessor :order
-
-  end
-
-  attr_accessor :current_order
-
-  def sort!
-    @routes.sort!{ |a, b| a.order <=> b.order }
-  end
-
-  class Node::Glob
-    def to_code
-      id = root.next_counter
-      "request.params << (globbed_params#{id} = [])
-       until request.path.empty?
-         globbed_params#{id} << request.path.shift
-         #{super}
-       end
-       request.path[0,0] = globbed_params#{id}
-       request.params.pop"
-    end
-  end
-
-  class Node::SpanningRegex
-    def to_code
-      params_count = @ordered_indicies.size
-      whole_path_var = "whole_path#{root.next_counter}"
-      "#{whole_path_var} = request.joined_path
-      if match = #{@matcher.inspect}.match(#{whole_path_var}) and match.begin(0).zero?
-        _#{whole_path_var} = request.path.dup
-        " << param_capturing_code << "
-        remaining_path = #{whole_path_var}[match[0].size + (#{whole_path_var}[match[0].size] == ?/ ? 1 : 0), #{whole_path_var}.size]
-        request.path = remaining_path.split('/')
-        #{node_to_code}
-        request.path = _#{whole_path_var}
-        request.params.slice!(#{-params_count}, #{params_count})
-      end
-      "
-    end
-  end
-
-  # Monkey patching the Request class. Using Rack::Utils.unescape rather than
-  # URI.unescape which can't handle utf-8 chars
-  class Request
-    def initialize(path, rack_request)
-      @rack_request = rack_request
-      @path = path.split(/\//).map{|part| Rack::Utils.unescape(part) }
-      @path.shift if @path.first == ''
-      @path.push('') if path[-1] == ?/
-      @extra_env = {}
-      @params = []
-      @acceptable_methods = Set.new
-    end
-  end
-
-  class Node::Path
-    def to_code
-      path_ivar = inject_root_ivar(self)
-      "#{"if !callback && request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
-        catch(:pass) do
-          response = ::Rack::Response.new
-          response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
-          return response.finish
-        end
-      end" if router.redirect_trailing_slash?}
-
-      #{"if request.#{router.ignore_trailing_slash? ? 'path_finished?' : 'path.empty?'}" unless route.match_partially}
-        catch(:pass) do
-          if callback
-            request.called = true
-            callback.call(Response.new(request, #{path_ivar}))
-          else
-            env = request.rack_request.dup.env
-            env['router.request'] = request
-            env['router.params'] ||= {}
-            #{"env['router.params'].merge!(Hash[#{param_names.inspect}.zip(request.params)])" if dynamic?}
-            env['router.params'] = env['router.params'].with_indifferent_access
-            @router.rewrite#{"_partial" if route.match_partially}_path_info(env, request)
-            response = @router.process_destination_path(#{path_ivar}, env)
-            return response unless router.pass_on_response(response)
-          end
-        end
-      #{"end" unless route.match_partially}"
-    end
-  end
-
-  class Node::FreeRegex
-    def to_code
-      id = root.next_counter
-      "whole_path#{id} = \"/\#{request.joined_path}\"
-      if match = #{matcher.inspect}.match(whole_path#{id}) and match[0].size == whole_path#{id}.size
-        request.extra_env['router.regex_match'] = match
-        old_path = request.path
-        request.path = ['']
-        " << (use_named_captures? ?
-        "match.names.size.times{|i| request.params << match[i + 1]} if match.respond_to?(:names) && match.names" : "") << "
-        #{super}
-        request.path = old_path
-        request.extra_env.delete('router.regex_match')
-        " << (use_named_captures? ?
-        "request.params.slice!(-match.names.size, match.names.size)" : ""
-        ) << "
-      end"
-    end
-  end
-end

data/lib/padrino-core/mounter/application_extension.rb

@@ -1,55 +0,0 @@
-module Padrino
-  class Mounter
-    module ApplicationExtension
-      attr_accessor :uri_root, :mounter_options
-      attr_writer :public_folder
-
-      def dependencies
-        @__dependencies ||= Dir.glob("#{root}/**/*.rb").delete_if { |path| path == app_file }
-      end
-
-      def prerequisites
-        @__prerequisites ||= []
-      end
-
-      def app_file
-        @__app_file ||= trace_method(:app_file) { mounter_options[:app_file] }
-      end
-
-      def root
-        @__root ||= trace_method(:root) { File.expand_path("#{app_file}/../") }
-      end
-
-      def public_folder
-        @public_folder ||= trace_method(:public_folder) { "" }
-      end
-
-      def app_name
-        @__app_name ||= mounter_options[:app_name] || self.to_s.underscore.to_sym
-      end
-
-      def setup_application!
-        @configured ||= trace_method(:setup_application!) do
-          $LOAD_PATH.concat(prerequisites)
-          require_dependencies if root.start_with?(Padrino.root)
-          true
-        end
-      end
-
-      private
-
-      def require_dependencies
-        Padrino.require_dependencies(dependencies, :force => true)
-      end
-
-      def trace_method(method_name)
-        value = baseclass.send(method_name) if baseclass != self && baseclass.respond_to?(method_name)
-        value || yield
-      end
-
-      def baseclass
-        @__baseclass ||= respond_to?(:superclass) ? superclass : self
-      end
-    end
-  end
-end

data/test/fixtures/apps/custom_dependencies/custom_dependencies.rb

@@ -1,11 +0,0 @@
-PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
-
-class CustomDependencies < Padrino::Application
-  set :reload, true
-end
-
-CustomDependencies.controllers do
-  get "/" do
-    "foo"
-  end
-end

data/test/fixtures/apps/stealthy/app.rb

@@ -1,7 +0,0 @@
-PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
-
-class SystemStealthyClassDemo < Padrino::Application
-  set :reload, true
-end
-
-Padrino.load!

data/test/fixtures/apps/stealthy/helpers/stealthy_class_helpers.rb

@@ -1,13 +0,0 @@
-class Boo
-  def self.class_method
-    "BooClass"
-  end
-end
-
-class Woo < Boo
-  def poo
-  end
-end
-
-class Soo < Boo
-end

data/test/test_configuration.rb

@@ -1,29 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "PadrinoConfiguration" do
-  it 'should be able to store values' do
-    Padrino.config.val1 = 12345
-    assert_equal 12345, Padrino.config.val1
-  end
-
-  it 'should be able to configure with block' do
-    Padrino.configure do |config|
-      config.val2 = 54321
-    end
-    assert_equal 54321, Padrino.config.val2
-  end
-
-  it 'should be able to configure with block' do
-    Padrino.configure :test do |config|
-      config.test1 = 54321
-    end
-    Padrino.configure :development do |config|
-      config.test1 = 12345
-    end
-    Padrino.configure :test, :development do |config|
-      config.both1 = 54321
-    end
-    assert_equal 54321, Padrino.config.test1
-    assert_equal 54321, Padrino.config.both1
-  end
-end

data/test/test_reloader_storage.rb

@@ -1,51 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Padrino::Reloader::Storage" do
-  describe "#classes" do
-    it 'should take an snapshot of the current loaded classes' do
-      snapshot = Padrino::Reloader::Storage.send(:object_classes)
-      assert_equal snapshot.include?(Padrino::Logger), true
-    end
-
-    it 'should return a Set object' do
-      snapshot = Padrino::Reloader::Storage.send(:object_classes)
-      assert_equal snapshot.kind_of?(Set), true
-    end
-
-    it 'should be able to process a the class name given a block' do
-      klasses = Padrino::Reloader::Storage.send(:object_classes) do |klass|
-        next unless klass.respond_to?(:name) # fix JRuby < 1.7.22
-        if klass.name =~ /^Padrino::/
-          klass
-        end
-      end
-
-      assert_equal (klasses.size > 1), true
-      klasses.each do |klass|
-        assert_match /^Padrino::/, klass.to_s
-      end
-    end
-  end
-
-  describe "#new_classes" do
-    before do
-      @snapshot = Padrino::Reloader::Storage.send(:object_classes)
-    end
-
-    it 'should return list of new classes' do
-      class OSTest; end
-      module OSTestModule; class B; end; end
-
-      new_classes = Padrino::Reloader::Storage.send(:new_classes, @snapshot)
-
-      assert_equal new_classes.size, 2
-      assert_equal new_classes.include?(OSTest), true
-      assert_equal new_classes.include?(OSTestModule::B), true
-    end
-
-    it 'should return a Set object' do
-      new_classes = Padrino::Reloader::Storage.send(:new_classes, @snapshot)
-      assert_equal new_classes.kind_of?(Set), true
-    end
-  end
-end