webroar 0.2.2

data/src/admin_panel/vendor/rails/railties/lib/rails/plugin.rb

@@ -0,0 +1,167 @@
+module Rails
+  # The Plugin class should be an object which provides the following methods:
+  #
+  # * +name+       - Used during initialisation to order the plugin (based on name and
+  #                  the contents of <tt>config.plugins</tt>).
+  # * +valid?+     - Returns true if this plugin can be loaded.
+  # * +load_paths+ - Each path within the returned array will be added to the <tt>$LOAD_PATH</tt>.
+  # * +load+       - Finally 'load' the plugin.
+  #
+  # These methods are expected by the Rails::Plugin::Locator and Rails::Plugin::Loader classes.
+  # The default implementation returns the <tt>lib</tt> directory as its <tt>load_paths</tt>, 
+  # and evaluates <tt>init.rb</tt> when <tt>load</tt> is called.
+  #
+  # You can also inspect the about.yml data programmatically:
+  #
+  #   plugin = Rails::Plugin.new(path_to_my_plugin)
+  #   plugin.about["author"] # => "James Adam"
+  #   plugin.about["url"] # => "http://interblah.net"
+  class Plugin
+    include Comparable
+    
+    attr_reader :directory, :name
+    
+    def initialize(directory)
+      @directory = directory
+      @name      = File.basename(@directory) rescue nil
+      @loaded    = false
+    end
+    
+    def valid?
+      File.directory?(directory) && (has_app_directory? || has_lib_directory? || has_init_file?)
+    end
+  
+    # Returns a list of paths this plugin wishes to make available in <tt>$LOAD_PATH</tt>.
+    def load_paths
+      report_nonexistant_or_empty_plugin! unless valid?
+      
+      returning [] do |load_paths|
+        load_paths << lib_path  if has_lib_directory?
+        load_paths << app_paths if has_app_directory?
+      end.flatten
+    end
+    
+    # Evaluates a plugin's init.rb file.
+    def load(initializer)
+      return if loaded?
+      report_nonexistant_or_empty_plugin! unless valid?
+      evaluate_init_rb(initializer)
+      @loaded = true
+    end
+    
+    def loaded?
+      @loaded
+    end
+    
+    def <=>(other_plugin)
+      name <=> other_plugin.name
+    end
+
+    def about
+      @about ||= load_about_information
+    end
+
+    # Engines are plugins with an app/ directory.
+    def engine?
+      has_app_directory?
+    end
+    
+    # Returns true if the engine ships with a routing file
+    def routed?
+      File.exist?(routing_file)
+    end
+
+
+    def view_path
+      File.join(directory, 'app', 'views')
+    end
+
+    def controller_path
+      File.join(directory, 'app', 'controllers')
+    end
+
+    def metal_path
+      File.join(directory, 'app', 'metal')
+    end
+
+    def routing_file
+      File.join(directory, 'config', 'routes.rb')
+    end
+    
+
+    private
+      def load_about_information
+        about_yml_path = File.join(@directory, "about.yml")
+        parsed_yml = File.exist?(about_yml_path) ? YAML.load(File.read(about_yml_path)) : {}
+        parsed_yml || {}
+      rescue Exception
+        {}
+      end
+
+      def report_nonexistant_or_empty_plugin!
+        raise LoadError, "Can not find the plugin named: #{name}"
+      end
+
+      
+      def app_paths
+        [ File.join(directory, 'app', 'models'), File.join(directory, 'app', 'helpers'), controller_path, metal_path ]
+      end
+      
+      def lib_path
+        File.join(directory, 'lib')
+      end
+
+      def classic_init_path
+        File.join(directory, 'init.rb')
+      end
+
+      def gem_init_path
+        File.join(directory, 'rails', 'init.rb')
+      end
+
+      def init_path
+        File.file?(gem_init_path) ? gem_init_path : classic_init_path
+      end
+
+
+      def has_app_directory?
+        File.directory?(File.join(directory, 'app'))
+      end
+
+      def has_lib_directory?
+        File.directory?(lib_path)
+      end
+
+      def has_init_file?
+        File.file?(init_path)
+      end
+
+
+      def evaluate_init_rb(initializer)
+        if has_init_file?
+          silence_warnings do
+            # Allow plugins to reference the current configuration object
+            config = initializer.configuration
+            
+            eval(IO.read(init_path), binding, init_path)
+          end
+        end
+      end               
+  end
+
+  # This Plugin subclass represents a Gem plugin. Although RubyGems has already
+  # taken care of $LOAD_PATHs, it exposes its load_paths to add them
+  # to Dependencies.load_paths.
+  class GemPlugin < Plugin
+    # Initialize this plugin from a Gem::Specification.
+    def initialize(spec, gem)
+      directory = spec.full_gem_path
+      super(directory)
+      @name = spec.name
+    end
+
+    def init_path
+      File.join(directory, 'rails', 'init.rb')
+    end
+  end
+end

data/src/admin_panel/vendor/rails/railties/lib/rails/rack/debugger.rb

@@ -0,0 +1,21 @@
+module Rails
+  module Rack
+    class Debugger
+      def initialize(app)
+        @app = app
+
+        require_library_or_gem 'ruby-debug'
+        ::Debugger.start
+        ::Debugger.settings[:autoeval] = true if ::Debugger.respond_to?(:settings)
+        puts "=> Debugger enabled"
+      rescue Exception
+        puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+        exit
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/src/admin_panel/vendor/rails/railties/lib/rails/rack/log_tailer.rb

@@ -0,0 +1,35 @@
+module Rails
+  module Rack
+    class LogTailer
+      EnvironmentLog = "#{File.expand_path(Rails.root)}/log/#{Rails.env}.log"
+
+      def initialize(app, log = nil)
+        @app = app
+
+        path = Pathname.new(log || EnvironmentLog).cleanpath
+        @cursor = ::File.size(path)
+        @last_checked = Time.now.to_f
+
+        @file = ::File.open(path, 'r')
+      end
+
+      def call(env)
+        response = @app.call(env)
+        tail_log
+        response
+      end
+
+      def tail_log
+        @file.seek @cursor
+
+        mod = @file.mtime.to_f
+        if mod > @last_checked
+          contents = @file.read
+          @last_checked = mod
+          @cursor += contents.size
+          $stdout.print contents
+        end
+      end
+    end
+  end
+end

data/src/admin_panel/vendor/rails/railties/lib/rails/rack/metal.rb

@@ -0,0 +1,51 @@
+require 'active_support/ordered_hash'
+
+module Rails
+  module Rack
+    class Metal
+      NotFoundResponse = [404, {}, []].freeze
+      NotFound = lambda { NotFoundResponse }
+
+      cattr_accessor :metal_paths
+      self.metal_paths = ["#{Rails.root}/app/metal"]
+      cattr_accessor :requested_metals
+
+      def self.metals
+        matcher = /#{Regexp.escape('/app/metal/')}(.*)\.rb\Z/
+        metal_glob = metal_paths.map{ |base| "#{base}/**/*.rb" }
+        all_metals = {}
+
+        metal_glob.each do |glob|
+          Dir[glob].sort.map do |file|
+            file = file.match(matcher)[1]
+            all_metals[file.camelize] = file
+          end
+        end
+
+        load_list = requested_metals || all_metals.keys
+
+        load_list.map do |requested_metal|
+          if metal = all_metals[requested_metal]
+            require metal
+            requested_metal.constantize
+          end
+        end.compact
+      end
+
+      def initialize(app)
+        @app = app
+        @metals = ActiveSupport::OrderedHash.new
+        self.class.metals.each { |app| @metals[app] = true }
+        freeze
+      end
+
+      def call(env)
+        @metals.keys.each do |app|
+          result = app.call(env)
+          return result unless result[0].to_i == 404
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/src/admin_panel/vendor/rails/railties/lib/rails/rack/static.rb

@@ -0,0 +1,46 @@
+require 'rack/utils'
+
+module Rails
+  module Rack
+    class Static
+      FILE_METHODS = %w(GET HEAD).freeze
+
+      def initialize(app)
+        @app = app
+        @file_server = ::Rack::File.new(File.join(RAILS_ROOT, "public"))
+      end
+
+      def call(env)
+        path        = env['PATH_INFO'].chomp('/')
+        method      = env['REQUEST_METHOD']
+
+        if FILE_METHODS.include?(method)
+          if file_exist?(path)
+            return @file_server.call(env)
+          else
+            cached_path = directory_exist?(path) ? "#{path}/index" : path
+            cached_path += ::ActionController::Base.page_cache_extension
+
+            if file_exist?(cached_path)
+              env['PATH_INFO'] = cached_path
+              return @file_server.call(env)
+            end
+          end
+        end
+
+        @app.call(env)
+      end
+
+      private
+        def file_exist?(path)
+          full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
+          File.file?(full_path) && File.readable?(full_path)
+        end
+
+        def directory_exist?(path)
+          full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
+          File.directory?(full_path) && File.readable?(full_path)
+        end
+    end
+  end
+end

data/src/admin_panel/vendor/rails/railties/lib/rails/rack.rb

@@ -0,0 +1,8 @@
+module Rails
+  module Rack
+    autoload :Debugger, "rails/rack/debugger"
+    autoload :LogTailer, "rails/rack/log_tailer"
+    autoload :Metal, "rails/rack/metal"
+    autoload :Static, "rails/rack/static"
+  end
+end

data/src/admin_panel/vendor/rails/railties/lib/rails/vendor_gem_source_index.rb

@@ -0,0 +1,140 @@
+require 'rubygems'
+require 'yaml'
+
+module Rails
+
+  class VendorGemSourceIndex
+    # VendorGemSourceIndex acts as a proxy for the Gem source index, allowing
+    # gems to be loaded from vendor/gems. Rather than the standard gem repository format,
+    # vendor/gems contains unpacked gems, with YAML specifications in .specification in
+    # each gem directory.
+    include Enumerable
+
+    attr_reader :installed_source_index
+    attr_reader :vendor_source_index
+
+    @@silence_spec_warnings = false
+
+    def self.silence_spec_warnings
+      @@silence_spec_warnings
+    end
+
+    def self.silence_spec_warnings=(v)
+      @@silence_spec_warnings = v
+    end
+
+    def initialize(installed_index, vendor_dir=Rails::GemDependency.unpacked_path)
+      @installed_source_index = installed_index
+      @vendor_dir = vendor_dir
+      refresh!
+    end
+
+    def refresh!
+      # reload the installed gems
+      @installed_source_index.refresh!
+      vendor_gems = {}
+
+      # handle vendor Rails gems - they are identified by having loaded_from set to ""
+      # we add them manually to the list, so that other gems can find them via dependencies
+      Gem.loaded_specs.each do |n, s|
+        next unless s.loaded_from.empty?
+        vendor_gems[s.full_name] = s
+      end
+
+      # load specifications from vendor/gems
+      Dir[File.join(Rails::GemDependency.unpacked_path, '*')].each do |d|
+        dir_name = File.basename(d)
+        dir_version = version_for_dir(dir_name)
+        spec = load_specification(d)
+        if spec
+          if spec.full_name != dir_name
+            # mismatched directory name and gem spec - produced by 2.1.0-era unpack code
+            if dir_version
+              # fix the spec version - this is not optimal (spec.files may be wrong)
+              # but it's better than breaking apps. Complain to remind users to get correct specs.
+              # use ActiveSupport::Deprecation.warn, as the logger is not set yet
+              $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems has a mismatched specification file."+
+                           " Run 'rake gems:refresh_specs' to fix this.") unless @@silence_spec_warnings
+              spec.version = dir_version
+            else
+              $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems is not in a versioned directory"+
+                           "(should be #{spec.full_name}).") unless @@silence_spec_warnings
+              # continue, assume everything is OK
+            end
+          end
+        else
+          # no spec - produced by early-2008 unpack code
+          # emulate old behavior, and complain.
+          $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems has no specification file."+
+                       " Run 'rake gems:refresh_specs' to fix this.") unless @@silence_spec_warnings
+          if dir_version
+            spec = Gem::Specification.new
+            spec.version = dir_version
+            spec.require_paths = ['lib']
+            ext_path = File.join(d, 'ext')
+            spec.require_paths << 'ext' if File.exist?(ext_path)
+            spec.name = /^(.*)-[^-]+$/.match(dir_name)[1]
+            files = ['lib']
+            # set files to everything in lib/
+            files += Dir[File.join(d, 'lib', '*')].map { |v| v.gsub(/^#{d}\//, '') }
+            files += Dir[File.join(d, 'ext', '*')].map { |v| v.gsub(/^#{d}\//, '') } if ext_path
+            spec.files = files
+          else
+            $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems not in a versioned directory."+
+                         " Giving up.") unless @@silence_spec_warnings
+            next
+          end
+        end
+        spec.loaded_from = File.join(d, '.specification')
+        # finally, swap out full_gem_path
+        # it would be better to use a Gem::Specification subclass, but the YAML loads an explicit class
+        class << spec
+          def full_gem_path
+            path = File.join installation_path, full_name
+            return path if File.directory? path
+            File.join installation_path, original_name
+          end
+        end
+        vendor_gems[File.basename(d)] = spec
+      end
+      @vendor_source_index = Gem::SourceIndex.new(vendor_gems)
+    end
+
+    def version_for_dir(d)
+      matches = /-([^-]+)$/.match(d)
+      Gem::Version.new(matches[1]) if matches
+    end
+
+    def load_specification(gem_dir)
+      spec_file = File.join(gem_dir, '.specification')
+      YAML.load_file(spec_file) if File.exist?(spec_file)
+    end
+
+    def find_name(*args)
+      @installed_source_index.find_name(*args) + @vendor_source_index.find_name(*args)
+    end
+
+    def search(*args)
+      # look for vendor gems, and then installed gems - later elements take priority
+      @installed_source_index.search(*args) + @vendor_source_index.search(*args)
+    end
+
+    def each(&block)
+      @vendor_source_index.each(&block)
+      @installed_source_index.each(&block)
+    end
+
+    def add_spec(spec)
+      @vendor_source_index.add_spec spec
+    end
+
+    def remove_spec(spec)
+      @vendor_source_index.remove_spec spec
+    end
+
+    def size
+      @vendor_source_index.size + @installed_source_index.size
+    end
+
+  end
+end

data/src/admin_panel/vendor/rails/railties/lib/rails/version.rb

@@ -0,0 +1,9 @@
+module Rails
+  module VERSION #:nodoc:
+    MAJOR = 2
+    MINOR = 3
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end