middleman-core 3.0.0.alpha.7

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/application/showexceptions.rb

@@ -0,0 +1,20 @@
+module Padrino
+  ##
+  # This module extend Sinatra::ShowExceptions adding Padrino as "Framework".
+  #
+  # @private
+  class ShowExceptions < Sinatra::ShowExceptions
+    private
+      def frame_class(frame)
+        if frame.filename =~ /lib\/sinatra.*\.rb|lib\/padrino.*\.rb/
+          "framework"
+        elsif (defined?(Gem) && frame.filename.include?(Gem.dir)) ||
+              frame.filename =~ /\/bin\/(\w+)$/ ||
+              frame.filename =~ /Ruby\/Gems/
+          "system"
+        else
+          "app"
+        end
+      end
+  end # ShowExceptions
+end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/caller.rb

@@ -0,0 +1,53 @@
+module Padrino
+
+  # List of callers in a Padrino application that should be ignored as part of a stack trace.
+  PADRINO_IGNORE_CALLERS = [
+    %r{lib/padrino-.*$},                             # all padrino code
+    %r{/padrino-.*/(lib|bin)},                       # all padrino code
+    %r{/bin/padrino$},                               # all padrino code
+    %r{/sinatra(/(base|main|showexceptions))?\.rb$}, # all sinatra code
+    %r{lib/tilt.*\.rb$},                             # all tilt code
+    %r{lib/rack.*\.rb$},                             # all rack code
+    %r{lib/mongrel.*\.rb$},                          # all mongrel code
+    %r{lib/shotgun.*\.rb$},                          # all shotgun lib
+    %r{bin/shotgun$},                                # shotgun binary
+    %r{\(.*\)},                                      # generated code
+    %r{shoulda/context\.rb$},                        # shoulda hacks
+    %r{mocha/integration},                           # mocha hacks
+    %r{test/unit},                                   # test unit hacks
+    %r{rake_test_loader\.rb},                        # rake hacks
+    %r{custom_require\.rb$},                         # rubygems require hacks
+    %r{active_support},                              # active_support require hacks
+    %r{/thor}                                        # thor require hacks
+  ] unless defined?(PADRINO_IGNORE_CALLERS)
+
+  ##
+  # Add rubinius (and hopefully other VM implementations) ignore patterns ...
+  #
+  PADRINO_IGNORE_CALLERS.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
+
+  private
+    ##
+    # The filename for the file that is the direct caller (first caller).
+    #
+    # @return [String]
+    #   The file the caller method exists in.
+    #
+    def self.first_caller
+      caller_files.first
+    end
+
+    #
+    # Like +Kernel#caller+ but excluding certain magic entries and without
+    # line / method information; the resulting array contains filenames only.
+    #
+    # @return [Array<String>]
+    #   The files of the calling methods.
+    #
+    def self.caller_files
+      caller(1).
+        map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
+        reject { |file,line| PADRINO_IGNORE_CALLERS.any? { |pattern| file =~ pattern } }.
+        map    { |file,line| file }
+    end
+end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/cli/adapter.rb

@@ -0,0 +1,24 @@
+module Padrino
+  module Cli
+    module Adapter
+      class << self
+        # Start for the given options a rackup handler
+        def start(options)
+          Padrino.run!(options.symbolize_keys)
+        end
+
+        # Method that stop (if exist) a running Padrino.application
+        def stop(options)
+          options.symbolize_keys!
+          if File.exist?(options[:pid])
+            pid = File.read(options[:pid]).to_i
+            print "=> Sending INT to process with pid #{pid} wait "
+            Process.kill(2, pid) rescue nil
+          else
+            puts "=> #{options[:pid]} not found!"
+          end
+        end
+      end # self
+    end # Adapter
+  end # Cli
+end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/cli/base.rb

@@ -0,0 +1,151 @@
+require 'thor'
+
+module Padrino
+  module Cli
+
+    class Base < Thor
+      include Thor::Actions
+
+      class_option :chdir, :type => :string, :aliases => "-c", :desc => "Change to dir before starting"
+      class_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development, :desc => "Padrino Environment"
+      class_option :help, :type => :boolean, :desc => "Show help usage"
+
+      desc "start", "Starts the Padrino application"
+      method_option :server,      :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
+      method_option :host,        :type => :string,  :aliases => "-h", :required => true, :default => "0.0.0.0", :desc => "Bind to HOST address"
+      method_option :port,        :type => :numeric, :aliases => "-p", :required => true, :default => 3000, :desc => "Use PORT"
+      method_option :daemonize,   :type => :boolean, :aliases => "-d", :desc => "Run daemonized in the background"
+      method_option :pid,         :type => :string,  :aliases => "-i", :desc => "File to store pid"
+      method_option :debug,       :type => :boolean,                   :desc => "Set debugging flags"
+      def start
+        prepare :start
+        require File.expand_path("../adapter", __FILE__)
+        require File.expand_path('config/boot.rb')
+        Padrino::Cli::Adapter.start(options)
+      end
+
+      desc "s", "Starts the Padrino application"
+      def s
+        invoke :start
+      end
+
+      desc "stop", "Stops the Padrino application"
+      method_option :pid, :type => :string,  :aliases => "-p", :desc => "File to store pid", :default => 'tmp/pids/server.pid'
+      def stop
+        prepare :stop
+        require File.expand_path("../adapter", __FILE__)
+        Padrino::Cli::Adapter.stop(options)
+      end
+
+      desc "rake", "Execute rake tasks"
+      method_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development
+      method_option :list,        :type => :string,  :aliases => "-T", :desc => "Display the tasks (matching optional PATTERN) with descriptions, then exit."
+      method_option :trace,       :type => :boolean, :aliases => "-t", :desc => "Turn on invoke/execute tracing, enable full backtrace."
+      method_option :verbose,     :type => :boolean, :aliases => "-v", :desc => "Log message to standard output."
+      def rake(*args)
+        prepare :rake
+        args << "-T" if options[:list]
+        args << options[:list]  unless options[:list].nil? || options[:list].to_s == "list"
+        args << "--trace" if options[:trace]
+        args << "--verbose" if options[:verbose]
+        ARGV.clear
+        ARGV.concat(args)
+        puts "=> Executing Rake #{ARGV.join(' ')} ..."
+        ENV['PADRINO_LOG_LEVEL'] ||= "test"
+        load File.expand_path('../rake.rb', __FILE__)
+        silence(:stdout) { require File.expand_path('config/boot.rb') }
+        PadrinoTasks.init(true)
+      end
+
+      desc "console", "Boots up the Padrino application irb console"
+      def console
+        prepare :console
+        require File.expand_path("../../version", __FILE__)
+        ARGV.clear
+        puts "=> Loading #{options.environment} console (Padrino v.#{Padrino.version})"
+        require 'irb'
+        require "irb/completion"
+        require File.expand_path('config/boot.rb')
+        require File.expand_path('../console', __FILE__)
+        IRB.start
+      end
+
+      desc "generate", "Executes the Padrino generator with given options."
+      def generate(*args)
+        # Build Padrino g as an alias of padrino-gen
+        begin
+          # We try to load the vendored padrino-gen if exist
+          padrino_gen_path = File.expand_path('../../../../../padrino-gen/lib', __FILE__)
+          $:.unshift(padrino_gen_path) if File.directory?(padrino_gen_path) && !$:.include?(padrino_gen_path)
+          require 'padrino-core/command'
+          require 'padrino-gen/command'
+          ARGV.shift
+          Padrino.bin_gen(ARGV)
+        rescue
+          puts "<= You need padrino-gen! Run: gem install padrino-gen"
+        end
+      end
+
+      desc "g", "Executes the Padrino generator with given options."
+      def g(*args)
+        invoke(:generate, args)
+      end
+
+      desc "gen", "Executes the Padrino generator with given options."
+      def gen(*args)
+        invoke(:generate, args)
+      end
+
+      desc "version", "Show current Padrino Version"
+      map "-v" => :version, "--version" => :version
+      def version
+        require 'padrino-core/version'
+        puts "Padrino v. #{Padrino.version}"
+      end
+
+      private
+        def prepare(task)
+          if options.help?
+            help(task.to_s)
+            raise SystemExit
+          end
+          ENV["PADRINO_ENV"] ||= ENV["RACK_ENV"] ||= options.environment.to_s
+          chdir(options.chdir)
+          unless File.exist?('config/boot.rb')
+            puts "=> Could not find boot file in: #{options.chdir}/config/boot.rb !!!"
+            raise SystemExit
+          end
+        end
+
+      protected
+        def self.banner(task=nil, *args)
+          "padrino #{task.name}"
+        end
+
+        def chdir(dir)
+          return unless dir
+          begin
+            Dir.chdir(dir.to_s)
+          rescue Errno::ENOENT
+            puts "=> Specified Padrino root '#{dir}' does not appear to exist!"
+          rescue Errno::EACCES
+            puts "=> Specified Padrino root '#{dir}' cannot be accessed by the current user!"
+          end
+        end
+
+        def capture(stream)
+          begin
+            stream = stream.to_s
+            eval "$#{stream} = StringIO.new"
+            yield
+            result = eval("$#{stream}").string
+          ensure
+            eval("$#{stream} = #{stream.upcase}")
+          end
+
+          result
+        end
+        alias :silence :capture
+    end # Base
+  end # Cli
+end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/cli/console.rb

@@ -0,0 +1,20 @@
+# Reloads classes
+def reload!
+  Padrino.reload!
+end
+
+# Show applications
+def applications
+  puts "==== List of Mounted Applications ====\n\n"
+  Padrino.mounted_apps.each do |app|
+    puts " * %-10s mapped to      %s" % [app.name, app.uri_root]
+  end
+  puts
+  Padrino.mounted_apps.map { |app| "#{app.name} => #{app.uri_root}" }
+end
+
+# Load apps
+Padrino.mounted_apps.each do |app|
+  puts "=> Loading Application #{app.app_class}"
+  app.app_obj.setup_application!
+end

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/cli/rake.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../tasks', __FILE__)
+require 'rake'
+require 'thor'
+require 'securerandom' unless defined?(SecureRandom)
+
+module PadrinoTasks
+  def self.init(init=false)
+    Padrino::Tasks.files.flatten.uniq.each { |rakefile| Rake.application.add_import(rakefile) rescue puts "<= Failed load #{ext}" }
+    if init
+      Rake.application.init
+      Rake.application.instance_variable_set(:@rakefile, __FILE__)
+      load(File.expand_path('../rake_tasks.rb', __FILE__))
+      Rake.application.load_imports
+      Rake.application.top_level
+    else
+      load(File.expand_path('../rake_tasks.rb', __FILE__))
+      Rake.application.load_imports
+    end
+  end
+end
+
+def shell
+  @_shell ||= Thor::Base.shell.new
+end

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/cli/rake_tasks.rb

@@ -0,0 +1,59 @@
+# Load rake tasks from common rake task definition locations
+Dir["lib/tasks/**/*.rake"].
+  concat(Dir["tasks/**/*.rake"]).
+  concat(Dir["{test,spec}/*.rake"]).each  { |rake| load(rake) }
+
+# Loads the Padrino applications mounted within the project
+# setting up the required environment for Padrino
+task :environment do
+  Padrino.mounted_apps.each do |app|
+    app.app_obj.setup_application!
+  end
+end
+
+desc "Generate a secret key"
+task :secret do
+  shell.say SecureRandom.hex(32)
+end
+
+# lists all routes of a given app
+def list_app_routes(app, args)
+  app_routes = app.named_routes
+  app_routes.reject! { |r| r.identifier.to_s !~ /#{args.query}/ } if args.query.present?
+  app_routes.map! { |r| [r.verb, r.name, r.path] }
+  return if app_routes.empty?
+  shell.say "\nApplication: #{app.app_class}", :yellow
+  app_routes.unshift(["REQUEST", "URL", "PATH"])
+  max_col_1 = app_routes.max { |a, b| a[0].size <=> b[0].size }[0].size
+  max_col_2 = app_routes.max { |a, b| a[1].size <=> b[1].size }[1].size
+  app_routes.each_with_index do |row, i|
+    message = [row[1].ljust(max_col_2+2), row[0].center(max_col_1+2), row[2]]
+    shell.say("    " + message.join(" "), i==0 ? :bold : nil)
+  end
+end
+
+desc "Displays a listing of the named routes within a project, optionally only those matched by [query]"
+task :routes, [:query] => :environment do |t, args|
+  Padrino.mounted_apps.each do |app|
+    list_app_routes(app, args)
+  end
+end
+
+desc "Displays a listing of the named routes a given app [app]"
+namespace :routes do
+  task :app, [:app] => :environment do |t, args|
+    app = Padrino.mounted_apps.find { |app| app.app_class == args.app }
+    list_app_routes(app, args) if app
+  end
+end
+
+desc "Generate the Rakefile"
+task :gen do
+  File.open(Padrino.root("Rakefile"), "w") do |file|
+    file.puts <<-RUBY.gsub(/^ {6}/, '')
+      require File.expand_path('../config/boot.rb', __FILE__)
+      require 'padrino-core/cli/rake'
+      PadrinoTasks.init
+    RUBY
+  end
+end

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/command.rb

@@ -0,0 +1,38 @@
+require 'rbconfig'
+
+module Padrino
+  ##
+  # This method return the correct location of padrino bin or
+  # exec it using Kernel#system with the given args
+  #
+  # @param [Array] args
+  #   command or commands to execute
+  #
+  # @return [Boolean]
+  #
+  # @example
+  #   Padrino.bin('start', '-e production')
+  #
+  def self.bin(*args)
+    @_padrino_bin ||= [self.ruby_command, File.expand_path("../../../bin/padrino", __FILE__)]
+    args.empty? ? @_padrino_bin : system(args.unshift(@_padrino_bin).join(" "))
+  end
+
+  ##
+  # Return the path to the ruby interpreter taking into account multiple
+  # installations and windows extensions.
+  #
+  # @return [String]
+  #   path to ruby bin executable
+  #
+  def self.ruby_command
+    @ruby_command ||= begin
+      ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+      ruby << RbConfig::CONFIG['EXEEXT']
+
+      # escape string in case path to ruby executable contain spaces.
+      ruby.sub!(/.*\s.*/m, '"\&"')
+      ruby
+    end
+  end
+end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/loader.rb

@@ -0,0 +1,210 @@
+module Padrino
+  class << self
+    ##
+    # Hooks to be called before a load/reload.
+    #
+    # @yield []
+    #   The given block will be called before Padrino was loaded/reloaded.
+    #
+    # @return [Array<Proc>]
+    #   The load/reload before hooks.
+    #
+    # @example
+    #   before_load do
+    #     pre_initialize_something
+    #   end
+    #
+    def before_load(&block)
+      @_before_load ||= []
+      @_before_load << block if block_given?
+      @_before_load
+    end
+
+    ##
+    # Hooks to be called after a load/reload.
+    #
+    # @yield []
+    #   The given block will be called after Padrino was loaded/reloaded.
+    #
+    # @return [Array<Proc>]
+    #   The load/reload hooks.
+    #
+    # @example
+    #   after_load do
+    #     DataMapper.finalize
+    #   end
+    #
+    def after_load(&block)
+      @_after_load ||= []
+      @_after_load << block if block_given?
+      @_after_load
+    end
+
+    ##
+    # The used +$LOAD_PATHS+ from Padrino.
+    #
+    # @return [Array<String>]
+    #   The load paths used by Padrino.
+    #
+    def load_paths
+      @_load_paths_was = %w(lib models shared).map { |path| Padrino.root(path) }
+      @_load_paths ||= @_load_paths_was
+    end
+
+    ##
+    # Requires necessary dependencies as well as application files from root
+    # lib and models.
+    #
+    # @return [Boolean]
+    #   returns true if Padrino is not already bootstraped otherwise else.
+    #
+    def load!
+      return false if loaded?
+      @_called_from = first_caller
+      Padrino.set_encoding
+      Padrino.set_load_paths(*load_paths) # We set the padrino load paths
+      Padrino::Logger.setup! # Initialize our logger
+      Padrino.require_dependencies("#{root}/config/database.rb", :nodeps => true) # Be sure to don't remove constants from dbs.
+      Padrino::Reloader.lock! # Now we can remove constant from here to down
+      Padrino.before_load.each(&:call) # Run before hooks
+      Padrino.dependency_paths.each { |path| Padrino.require_dependencies(path) }
+      Padrino.after_load.each(&:call) # Run after hooks
+      Padrino::Reloader.run!
+      Thread.current[:padrino_loaded] = true
+    end
+
+    ##
+    # Clear the padrino env.
+    #
+    # @return [NilClass]
+    #
+    def clear!
+      Padrino.clear_middleware!
+      Padrino.mounted_apps.clear
+      @_load_paths = nil
+      @_dependency_paths = nil
+      @_global_configuration = nil
+      Padrino.before_load.clear
+      Padrino.after_load.clear
+      Padrino::Reloader.clear!
+      Thread.current[:padrino_loaded] = nil
+    end
+
+    ##
+    # Method for reloading required applications and their files.
+    #
+    def reload!
+      Padrino.before_load.each(&:call) # Run before hooks
+      Padrino::Reloader.reload! # detects the modified files
+      Padrino.after_load.each(&:call) # Run after hooks
+    end
+
+    ##
+    # This adds the ablity to instantiate {Padrino.load!} after
+    # {Padrino::Application} definition.
+    #
+    def called_from
+      @_called_from || first_caller
+    end
+
+    ##
+    # Determines whether Padrino was loaded with {Padrino.load!}.
+    #
+    # @return [Boolean]
+    #   Specifies whether Padrino was loaded.
+    #
+    def loaded?
+      Thread.current[:padrino_loaded]
+    end
+
+    ##
+    # Attempts to require all dependency libs that we need.
+    # If you use this method we can perform correctly a Padrino.reload!
+    # Another good thing that this method are dependency check, for example:
+    #
+    #   # models
+    #   #  \-- a.rb => require something of b.rb
+    #   #  \-- b.rb
+    #
+    # In the example above if we do:
+    #
+    #   Dir["/models/*.rb"].each { |r| require r }
+    #
+    # we get an error, because we try to require first +a.rb+ that need
+    # _something_ of +b.rb+.
+    #
+    # With this method we don't have this problem.
+    #
+    # @param [Array<String>] paths
+    #   The paths to require.
+    #
+    # @example For require all our app libs we need to do:
+    #   require_dependencies("#{Padrino.root}/lib/**/*.rb")
+    #
+    def require_dependencies(*paths)
+      options = paths.extract_options!
+
+      # Extract all files to load
+      files = paths.flatten.map { |path| Dir[path] }.flatten.uniq.sort
+
+      while files.present?
+        # List of errors and failed files
+        errors, failed = [], []
+
+        # We need a size to make sure things are loading
+        size_at_start = files.size
+
+        # Now we try to require our dependencies, we dup files
+        # so we don't perform delete on the original array during
+        # iteration, this prevent problems with rubinus
+        files.dup.each do |file|
+          begin
+            Padrino::Reloader.safe_load(file, options.dup)
+            files.delete(file)
+          rescue LoadError => e
+            errors << e
+            failed << file
+          rescue NameError => e
+            errors << e
+            failed << file
+          rescue Exception => e
+            raise e
+          end
+        end
+
+        # Stop processing if nothing loads or if everything has loaded
+        raise errors.last if files.size == size_at_start && files.present?
+        break if files.empty?
+      end
+    end
+
+    ##
+    # Returns default list of path globs to load as dependencies
+    # Appends custom dependency patterns to the be loaded for Padrino.
+    #
+    # @return [Array<String>]
+    #   The dependencey paths.
+    #
+    # @example
+    #   Padrino.dependency_paths << "#{Padrino.root}/uploaders/*.rb"
+    #
+    def dependency_paths
+      @_dependency_paths_was = [
+        "#{root}/config/database.rb", "#{root}/lib/**/*.rb", "#{root}/shared/lib/**/*.rb",
+        "#{root}/models/**/*.rb", "#{root}/shared/models/**/*.rb", "#{root}/config/apps.rb"
+      ]
+      @_dependency_paths ||= @_dependency_paths_was
+    end
+
+    ##
+    # Concat to +$LOAD_PATH+ the given paths.
+    #
+    # @param [Array<String>] paths
+    #   The paths to concat.
+    #
+    def set_load_paths(*paths)
+      $:.concat(paths); load_paths.concat(paths)
+      $:.uniq!; load_paths.uniq!
+    end
+  end # self
+end # Padrino