app.rb

require File.join(File.dirname(__FILE__), 'init')

require 'yard'
require 'sinatra'
require 'json'
require 'yaml'
require 'fileutils'
require 'airbrake'

require 'extensions'
require 'scm_router'
require 'scm_checkout'
require 'gems_router'
require 'local_gems_router'
require 'featured_router'
require 'stdlib_router'
require 'recent_store'

class Hash; alias blank? empty? end
class NilClass; def blank?; true end end

$rvm_path=nil
[File.expand_path("~/.rvm"),"/usr/local/rvm"].each do |path|
  $rvm_path= path if Dir.exists?(path)
end

if ! $rvm_path.blank?
  log.info "Using RVM at '#{$rvm_path}'"
else
  log.info "No RVM found."
end

$rbenv_path=nil
[File.expand_path("~/.rbenv"),"/usr/local/rbenv"].each do |path|
  $rbenv_path= path if Dir.exists?(path)
end

if ! $rbenv_path.blank?
  log.info "Using rbenv at '#{$rbenv_path}'"
else
  log.info "No rbenv found."
end

class DocServer < Sinatra::Base
  include YARD::Server

  DISALLOWED_GEMS = %w(netsuite_client)
  DISALLOWED_PROJECTS = %w()
  WHITELISTED_GEMS = %w(yard)
  WHITELISTED_PROJECTS = %w(lsegal/yard)

  def self.adapter_options
    caching = %w(staging production).include?(ENV['RACK_ENV'])
    {
      :libraries => {},
      :options => {caching: caching, single_library: false},
      :server_options => {DocumentRoot: STATIC_PATH}
    }
  end

  @@local_gems_index = nil
  def self.local_gems_index
    unless @@local_gems_index
      @@local_gems_index= {}

      if $rvm_path
        # very fast but more brittle when rvm changes plans on gemsets and storage and paths
        gem_paths=Dir.glob(File.join($rvm_path,"gems/*"))

        gem_paths.each do |gem_path|

          local_gems=[]

          # copied from Gem::Specification._all
          # because of Bundler magic; we can't use
          # Gem::Specification.dirs= [gem_path]; Gem::Specification,all
          # *all* will always refer to you Bundler Gemfile

          Dir[File.join(gem_path,'specifications', "*.gemspec")].each { |path|
            spec = Gem::Specification.load path.untaint
            # #load returns nil if the spec is bad, so we just ignore
            # it at this stage
            local_gems << spec if spec
          }

          local_gems.each do |spec|
            @@local_gems_index[spec.name]||={}
            @@local_gems_index[spec.name][spec.version.to_s] = File.join(gem_path,"gems","#{spec.name}-#{spec.version.to_s}")
          end
        end

      end

      if $rbenv_path
        # very fast but more brittle when rbenv changes plans on gem storage and paths
        rubies = Dir.glob(File.join($rbenv_path,"versions/*"))

        rubies.each do |ruby_path|
          gem_path = Dir.glob(File.join(ruby_path,'lib/ruby/gems/*')).first

          local_gems=[]

          Dir[File.join(gem_path,'specifications', "*.gemspec")].each { |path|
            spec = Gem::Specification.load path.untaint
            local_gems << spec if spec
          }

          local_gems.each do |spec|
            @@local_gems_index[spec.name]||={}
            @@local_gems_index[spec.name][spec.version.to_s] = File.join(gem_path,"gems","#{spec.name}-#{spec.version.to_s}")
          end
        end

      end

    end
    @@local_gems_index
  end

  def self.load_configuration
    set :name, 'RubyDoc.info'
    set :url, 'http://rubydoc.info'

    return unless File.file?(CONFIG_FILE)

    puts ">> Loading #{CONFIG_FILE}"
    YAML.load_file(CONFIG_FILE).each do |key, value|
      set key, value
      the_options[key.to_sym] = value
      $DISQUS = value if key == 'disqus' # HACK for DISQUS setting
      $CLICKY = value if key == 'clicky' # Hack for Clicky setting
      $GOOGLE_ANALYTICS = value if key == 'google_analytics' # Hack for GA settings
    end
  end

  def self.copy_static_files
    # Copy template files
    puts ">> Copying static system files..."
    Commands::StaticFileCommand::STATIC_PATHS <<
      File.join(TEMPLATES_PATH, 'default', 'fulldoc', 'html')
    Commands::StaticFileCommand::STATIC_PATHS.each do |path|
      %w(css js images).each do |ext|
        srcdir, dstdir = File.join(path, ext), File.join('public', ext)
        next unless File.directory?(srcdir)
        system "mkdir -p #{dstdir} && cp #{srcdir}/* #{dstdir}/"
      end
    end
  end

  def self.load_gems_adapter
    remote_file = REMOTE_GEMS_FILE
    contents = File.readlines(remote_file)
    puts ">> Loading remote gems list..."
    opts = adapter_options
    contents.each do |line|
      name, *versions = *line.split(/\s+/)
      opts[:libraries][name] = versions.map do |v|
        ver, platform = *v.split(',')
        lib = LibraryVersion.new(name, ver, nil, :remote_gem)
        lib.platform = platform
        lib
      end
    end
    opts[:options][:router] = GemsRouter
    set :gems_adapter, RackAdapter.new(*opts.values)
  rescue Errno::ENOENT
    log.error "No remote_gems file to load remote gems from, not serving gems."
  end

  def self.load_local_gems_adapter
    puts ">> Loading local gems list..."

    opts = adapter_options

    self.local_gems_index.each do |key, value|
      opts[:libraries][key] = value.map do |version, gem_src_dir|
        LibraryVersion.new(key, version, nil, :local_gem)
      end
    end

    opts[:options][:router] = LocalGemsRouter
    set :local_gems_adapter, RackAdapter.new(*opts.values)
  rescue Errno::ENOENT
    log.error "No gems file to load local gems from, not serving local gems."
  end

  def self.load_scm_adapter
    opts = adapter_options
    opts[:options][:router] = ScmRouter
    opts[:libraries] = ScmLibraryStore.new
    set :scm_adapter, RackAdapter.new(*opts.values)
  end

  def self.find_featured_yardoc(name, libdir)
    [File.join(FEATURED_PATH, libdir, '.yardoc'), File.join(libdir, '.yardoc')].each do |path|
      return path if File.directory?(path)
    end
    log.error "Invalid featured repository #{libdir} for #{name}"
    exit
  end

  def self.load_featured_adapter
    raise(Errno::ENOENT) unless the_options.has_key?(:featured)
    opts = adapter_options
    opts[:options][:router] = FeaturedRouter
    the_options[:featured].each do |key, value|
      opts[:libraries][key] = case value
      when String
        [LibraryVersion.new(key, nil, find_featured_yardoc(key, value))]
      when Array, Hash
        value = value.first if Array === value
        value.map do |version, libdir|
          LibraryVersion.new(key, version, find_featured_yardoc(key, libdir))
        end
      end
    end
    set :featured_adapter, RackAdapter.new(*opts.values)
  rescue Errno::ENOENT
    log.error "No featured section in config.yaml, not serving featured docs."
    set :featured_adapter, nil
  end


  def self.load_stdlib_adapter
    unless File.directory?(STDLIB_PATH)
      log.error "No stdlib repository, not serving standard library"
      return
    end

    require 'stdlib_installer'
    if $rvm_path
      src_paths=Dir.glob(File.join($rvm_path,"**/ruby.c"))
      src_paths.each do |src_path|
        src_dir = File.dirname(src_path)
        version = File.basename(src_dir)
        version = File.basename(File.dirname(src_dir)) if version !~ /[0-9]/
        unless File.directory?(File.join(STDLIB_PATH,version))
          log.warn "Installing RVM stdlib #{version}"
          StdlibInstaller.new(src_dir, version).install
        end
      end
    end
    if $rbenv_path
      src_paths=Dir.glob(File.join($rbenv_path,"sources/**/ruby.c"))
      src_paths.each do |src_path|
        src_dir = File.dirname(src_path)
        version = File.basename(src_dir)
        version = File.basename(File.dirname(src_dir)) if version !~ /[0-9]/
        unless File.directory?(File.join(STDLIB_PATH,version))
          log.warn "Installing RBENV stdlib #{version}"
          StdlibInstaller.new(src_dir, version).install
        end
      end
    end

    opts = adapter_options
    opts[:options][:router] = StdlibRouter
    versions = Dir.glob(File.join(STDLIB_PATH, '*'))
    versions.sort_by {|v| File.basename(v) }.each do |version|
      next unless File.directory?(version)
      version = File.basename(version)
      libs = Dir.glob(File.join(STDLIB_PATH, version, '*'))
      libs.each do |lib|
        next unless File.directory?(lib)
        libname = File.basename(lib)
        yardoc = File.join(lib, '.yardoc')
        opts[:libraries][libname] ||= []
        opts[:libraries][libname] << LibraryVersion.new(libname, version, nil, :disk_on_demand)
      end
    end
    set :stdlib_adapter, RackAdapter.new(*opts.values)
  end

  def self.post_all(*args, &block)
    args.each {|arg| post(arg, &block) }
  end

  class << self; attr_accessor :the_options end
  @the_options = {}

  use Rack::Deflater
  use Rack::ConditionalGet
  use Rack::Head

  enable :static
  enable :dump_errors
  enable :lock
  disable :caching
  disable :raise_errors

  set :views, TEMPLATES_PATH
  set :public_folder, STATIC_PATH
  set :repos, REPOS_PATH
  set :tmp, TMP_PATH

  configure(:production) do
    enable :caching
    enable :logging
    # log to file
    file = File.open("log/sinatra.log", "a")
    STDOUT.reopen(file)
    STDERR.reopen(file)
  end

  configure do
    load_configuration
    load_gems_adapter
    load_local_gems_adapter
    load_scm_adapter
    load_featured_adapter
    load_stdlib_adapter
    copy_static_files
  end

  helpers do
    include YARD::Templates::Helpers::HtmlHelper

    def recent_store
      @@recent_store ||= RecentStore.new(20)
    end

    def notify_error
      if settings.airbrake && %w(staging production).include?(ENV['RACK_ENV'])
        Airbrake.configure do |config|
          config.api_key = settings.airbrake
        end unless @airbrake_configured
        @airbrake_configured = true
        exc = request.env['sinatra.error']
        Airbrake.notify exc,
          error_message: exc.message,
          request: request,
          environment: request.env,
          session: request.session,
          backtrace: caller
      end
      erb(:error)
    end

    def cache(output)
      return output if settings.caching != true
      path = request.path.gsub(%r{^/|/$}, '')
      path = 'index' if path == ''
      path = File.join(settings.public_folder, path + '.html')
      FileUtils.mkdir_p(File.dirname(path))
      File.open(path, "w") {|f| f.write(output) }
      output
    end

    def next_row(prefix = 'r', base = 1)
      prefix + (@row = @row == base ? base + 1 : base).to_s
    end

    def translate_file_links(extra)
      extra.sub(%r{^/(frames/)?file:}, '/\1file/')
    end

    def shorten_commit_link(commit)
      commit.slice(0..5)
    end
  end

  # Filters

  # Always reset safe mode
  before { YARD::Config.options[:safe_mode] = true }

  # Checkout and post commit hooks

  post_all '/checkout', '/projects/update' do
    begin
      if params[:payload]
        payload = JSON.parse(params[:payload])
        url = payload["repository"]["url"]
        commit = nil
      else
        url = params[:url]
        commit = params[:commit]
        commit = nil if commit == ''
      end

      url = url.sub(%r{^http://}, 'git://')
      if url =~ %r{github\.com/([^/]+)/([^/]+)}
        username, project = $1, $2
        if WHITELISTED_PROJECTS.include?("#{username}/#{project}")
          puts "Dropping safe mode for #{username}/#{project}"
          YARD::Config.options[:safe_mode] = false
        end
        if DISALLOWED_PROJECTS.include?("#{username}/#{project}")
          return status(503) && "Cannot parse this project"
        end
      end

      scm = GithubCheckout.new(self, url, commit)
      scm.flush_cache
      scm.checkout
      "OK"
    rescue InvalidSchemeError
      "INVALIDSCHEME"
    end
  end

  get '/checkout/:username/:project/:commit' do
    git = GithubCheckout.new(self, [params[:username], params[:project]], params[:commit])
    if libs = settings.scm_adapter.libraries[git.name]
      if lib = libs.find {|l| l.version == git.commit }
        return "NO" unless File.exist?(File.join(lib.source_path, '.yardoc', 'complete'))
        return "YES"
      end
    end

    if File.exist?(git.error_file)
      puts "#{git.error_file} found"
      "ERROR"
    else
      puts "#{git.error_file} not found"
      "NO"
    end
  end

  # Main URL handlers

  get %r{^/github(?:/([a-z])?)?$} do |letter|
    if letter.nil?
      @adapter = settings.scm_adapter
      @libraries = recent_store
      cache erb(:home)
    else
      @letter = letter
      @adapter = settings.scm_adapter
      @libraries = @adapter.libraries
      @sorted_libraries = @libraries.sorted_by_project(@letter)
      cache erb(:scm_index)
    end
  end

  get %r{^/gems(?:/([a-z])?)?$} do |letter|
    @letter = letter || 'a'
    @adapter = settings.gems_adapter
    @libraries = @adapter.libraries.find_all {|k, v| k[0].downcase == @letter }
    cache erb(:gems_index)
  end

  get %r{^/local_gems(?:/([a-z])?)?$} do |letter|
    @letter = letter || 'a'
    @adapter = settings.local_gems_adapter
    @libraries = @adapter.libraries.find_all {|k, v| k[0].downcase == @letter }
    cache erb(:local_gems_index)
  end

  get %r{^/(?:(?:search|list)/)?github/([^/]+)/([^/]+)} do |username, project|
    @username, @project = username, project
    if WHITELISTED_PROJECTS.include?("#{username}/#{project}")
      puts "Dropping safe mode for #{username}/#{project}"
      YARD::Config.options[:safe_mode] = false
    end
    result = settings.scm_adapter.call(env)
    return status(404) && erb(:scm_404) if result.first == 404
    result
  end

  get %r{^/(?:(?:search|list)/)?gems/([^/]+)} do |gemname|
    return status(503) && "Cannot parse this gem" if DISALLOWED_GEMS.include?(gemname)
    if WHITELISTED_GEMS.include?(gemname)
      puts "Dropping safe mode for #{gemname}"
      YARD::Config.options[:safe_mode] = false
    end
    @gemname = gemname
    result = settings.gems_adapter.call(env)
    return status(404) && erb(:gems_404) if result.first == 404
    result
  end

  get %r{^/(?:(?:search|list)/)?local_gems/([^/]+)} do |gemname|
    return status(503) && "Cannot parse this gem" if DISALLOWED_GEMS.include?(gemname)
    if WHITELISTED_GEMS.include?(gemname)
      puts "Dropping safe mode for #{gemname}"
      YARD::Config.options[:safe_mode] = false
    end
    @gemname = gemname
    result = settings.local_gems_adapter.call(env)
    return status(404) && erb(:gems_404) if result.first == 404
    result
  end

  # Stdlib

  get %r{^/(?:(?:search|list)/)?stdlib/([^/]+)} do |libname|
    YARD::Config.options[:safe_mode] = false
    @libname = libname
    pass unless settings.stdlib_adapter.libraries[libname]
    result = settings.stdlib_adapter.call(env)
    return status(404) && erb(:stdlib_404) if result.first == 404
    result
  end

  get %r{^/stdlib/?$} do
    @stdlib = settings.stdlib_adapter.libraries
    cache erb(:stdlib_index)
  end

  # Featured libraries

  get %r{^/(?:(?:search|list)/)?docs/([^/]+)} do |libname|
    YARD::Config.options[:safe_mode] = false
    @libname = libname
    pass unless settings.featured_adapter.libraries[libname]
    result = settings.featured_adapter.call(env)
    return status(404) && erb(:featured_404) if result.first == 404
    result
  end

  get %r{^/(featured|docs/?$)} do
    @featured = settings.featured_adapter.libraries
    cache erb(:featured_index)
  end

  # Simple search interfaces

  get %r{^/find/github} do
    @search = params[:q]
    @adapter = settings.scm_adapter
    @libraries = @adapter.libraries
    @sorted_libraries = @libraries.sorted_by_project("*#{@search}")
    erb(:scm_index)
  end

  get %r{^/find/gems} do
    self.class.load_gems_adapter unless defined? settings.gems_adapter
    @search = params[:q]
    @adapter = settings.gems_adapter
    @libraries = @adapter.libraries.find_all {|k,v| k.match(/#{Regexp.quote @search}/) }
    erb(:gems_index)
  end

  get %r{^/find/local_gems} do
    self.class.load_local_gems_adapter unless defined? settings.local_gems_adapter
    @search = params[:q]
    @adapter = settings.local_gems_adapter
    @libraries = @adapter.libraries.find_all {|k,v| k.match(/#{Regexp.quote @search}/) }
    erb(:local_gems_index)
  end

  # Redirect /docs/ruby-core
  get(%r{^/docs/ruby-core/?(.*)}) do |all|
    redirect("/stdlib/core/#{all}", 301)
  end

  # Redirect /docs/ruby-stdlib
  get(%r{^/docs/ruby-stdlib/?(.*)}) do |all|
    redirect("/stdlib")
  end

  # Old URL structure redirection for yardoc.org

  get(%r{^/docs/([^/]+)-([^/]+)(/?.*)}) do |user, proj, extra|
    redirect("/github/#{user}/#{proj}#{translate_file_links extra}", 301)
  end

  get(%r{^/docs/([^/]+)(/?.*)}) do |lib, extra|
    redirect("/gems/#{lib}#{translate_file_links extra}", 301)
  end

  get('/docs/?') { redirect('/github', 301) }

  # Old URL structure redirection for rdoc.info

  get(%r{^/(?:projects|rdoc)/([^/]+)/([^/]+)(/?.*)}) do |user, proj, extra|
    redirect("/github/#{user}/#{proj}", 301)
  end

  # Root URL redirection

  get '/' do
    @adapter = settings.scm_adapter
    @libraries = recent_store
    @featured = settings.featured_adapter.libraries if settings.featured_adapter
    cache erb(:home)
  end

  error do
    @page_title = "Unknown Error!"
    @error = "Something quite unexpected just happened.
      Thanks to <a href='http://airbrake.io'>Airbrake</a> we know about the
      issue, but feel free to email <a href='mailto:support@rdoc.info'>someone</a>
      about it."
    notify_error
  end
end