doc 0.0.0.0 → 0.0.1

data/lib/doc/configurator/ruby/path_info.rb

@@ -0,0 +1,38 @@
+module Doc
+  class Configurator
+    class Ruby
+      class PathInfo < Struct.new(:path, :name, :type, :full_version, :parts)
+        private_class_method :new
+        def self.latest_matching(version, paths)
+          paths.map(&method(:for_path)).compact.grep(version).sort.last
+        end
+
+        def self.for_path(path)
+          name = path.basename.to_s
+          if name =~ /^ruby-(\d+\.\d+\.\d+-p\d+)(?i:\.(tar\.(?:gz|bz2)|tgz|tbz|zip))?$/
+            extension = $2 ? $2.downcase : :dir
+            type = ({'tar.bz2' => 'tbz', 'tar.gz' => 'tgz'}[extension] || extension).to_sym
+            new(path, name, type, $1, $1.scan(/\d+/).map(&:to_i))
+          end
+        end
+
+        def type_priority
+          @type_priority ||= {:zip => 0, :tgz => 1, :tbz => 2, :dir => 3}[type]
+        end
+
+        def sort_by
+          @sort_by ||= [parts, type_priority]
+        end
+
+        include Comparable
+        def <=>(other)
+          sort_by <=> other.sort_by
+        end
+
+        def ===(other)
+          parts === other.parts
+        end
+      end
+    end
+  end
+end

data/lib/doc/configurator/ruby/source.rb

@@ -0,0 +1,216 @@
+require 'net/ftp'
+require 'net/ftp/list'
+require 'tempfile'
+require 'tmpdir'
+require 'timeout'
+
+module Doc
+  class Configurator
+    class Ruby
+      module Source
+        def by_binary(binary, update)
+          binary = (binary || 'ruby').to_s
+          version = VersionSpecifier.new(`#{binary} -e 'print "\#{RUBY_VERSION}-p\#{RUBY_PATCHLEVEL}"'`)
+          if $?.success?
+            if version.valid?
+              by_version(version, update)
+            else
+              raise "invalid version from `#{binary}`: #{version.to_s.inspect}"
+            end
+          else
+            raise "failed to get version from `#{binary}`"
+          end
+        end
+
+        def by_version(version, update)
+          version = VersionSpecifier.new(version)
+          if version.valid?
+            if (update && !version.full_version?) || !path_for_version(version)
+              download_version(version)
+            end
+            if path = path_for_version(version)
+              path.directory? ? from_dir(path) : from_archive(path)
+            else
+              raise "can't get ruby #{version}"
+            end
+          else
+            raise "version should be in format X.Y, X.Y.Z or X.Y.Z-pPPP, download archive if you need release candidate or other version"
+          end
+        end
+
+        def from_archive(path)
+          path = FSPath(path)
+          if path.file?
+            if path.basename.to_s =~ /^(.*)(?i:\.(tar\.(?:gz|bz2)|tgz|tbz|zip))$/
+              dir, extension = sources_dir / $1, $2.downcase
+              unless dir.exist?
+                Dir.mktmpdir 'ruby' do |d|
+                  begin
+                    case extension
+                    when 'tbz', 'tar.bz2'
+                      Command.run('tar', '-xjf', path, '-C', d)
+                    when 'tgz', 'tar.gz'
+                      Command.run('tar', '-xzf', path, '-C', d)
+                    when 'zip'
+                      Command.run('unzip', '-q', path, '-d', d)
+                    end
+
+                    children = FSPath(d).children
+                    if children.length == 1
+                      children.first.rename(dir)
+                    else
+                      dir.mkpath
+                      FileUtils.mv children, dir
+                    end
+                  rescue SystemExit => e
+                    raise "got #{e} trying to extract archive"
+                  end
+                end
+              end
+              from_dir(dir)
+            else
+              raise "#{path} doesn't seem to be archive of known type"
+            end
+          else
+            raise "#{path} is not a file"
+          end
+        end
+
+        def from_dir(path)
+          path = FSPath(path)
+          if path.directory?
+            version_path = path / 'version.h'
+            if version_path.file? && version_path.read['RUBY_VERSION']
+              dot_document_path = path / '.document'
+              if dot_document_path.size?
+                path.expand_path
+              else
+                raise "#{path} doesn't contain .document file or it is empty"
+              end
+            else
+              raise "#{path} doesn't contain version.h file or it has no RUBY_VERSION in it"
+            end
+          else
+            raise "#{path} is not a directory"
+          end
+        end
+
+      private
+
+        def path_for_version(version)
+          if path_info = PathInfo.latest_matching(version, sources_dir.children)
+            path_info.path
+          end
+        end
+
+        def tempfile_for(dst)
+          Tempfile.open 'ruby' do |f|
+            path = FSPath(f.path)
+            yield path
+            path.rename(dst)
+          end
+        end
+
+        def latest_version_from_tag_list(command, regexp, version)
+          IO.popen(command, &:readlines).map do |line|
+            if line.strip =~ regexp
+              VersionSpecifier.new($1)
+            end
+          end.compact.sort.grep(version).last
+        end
+
+        def tmpdir_for_latest_version_from_tag_list(command, regexp, version)
+          if tag_version = latest_version_from_tag_list(command, regexp, version)
+            unless path_for_version(tag_version)
+              Dir.mktmpdir 'ruby' do |d|
+                tmp_dir = FSPath(d) / tag_version.dir_name
+                if yield(tmp_dir, tag_version)
+                  tmp_dir.rename(sources_dir / tag_version.dir_name)
+                end
+              end
+            end
+            path_for_version(tag_version)
+          end
+        end
+
+        def download_version(version)
+          download_version_via(:git_pull, version) || download_version_via(:git_tarball, version)
+          # git doesn't always have latest version so fast download from there, but verify latest from ftp/svn
+          download_version_via(:ftp, version) || download_version_via(:svn, version)
+        end
+
+        def download_version_via(type, version)
+          $stderr.puts "Checking/downloading ruby #{version} via #{type}"
+          Timeout.timeout(90) do
+            send("download_version_via_#{type}", version)
+          end
+        end
+
+        FTP_HOST = 'ftp.ruby-lang.org'
+        SVN_TAGS_URL = 'http://svn.ruby-lang.org/repos/ruby/tags/'
+        SVN_TAG_LIST_COMMAND = "svn list --non-interactive #{SVN_TAGS_URL}"
+        SVN_TAG_REGEXP = /^(v\d+(?:_\d+){3})\/$/
+        GIT_BARE_URL = 'github.com/ruby/ruby'
+        GIT_URL = "git://#{GIT_BARE_URL}.git"
+        GIT_TAG_LIST_COMMAND = "git ls-remote -t #{GIT_URL}"
+        GIT_TAG_REGEXP = /^.*\t(refs\/tags\/v\d+(?:_\d+){3})$/
+
+        def download_version_via_ftp(version)
+          Net::FTP.open(FTP_HOST) do |ftp|
+            ftp.passive = true
+            ftp.login
+
+            ftp_dir = FSPath('/pub/ruby') / version.parts[0, 2].join('.')
+            entries = ftp.list(ftp_dir.to_s).map{ |e| Net::FTP::List.parse(e) }
+            if archive_info = PathInfo.latest_matching(version, entries.select(&:file?))
+              unless path_for_version(archive_info)
+                entry = archive_info.path
+                tempfile_for(sources_dir / entry.basename) do |f|
+                  ftp.getbinaryfile(ftp_dir / entry.basename, f)
+                end
+              end
+              path_for_version(archive_info)
+            end
+          end
+        end
+
+        def download_version_via_svn(version)
+          tmpdir_for_latest_version_from_tag_list(SVN_TAG_LIST_COMMAND, SVN_TAG_REGEXP, version) do |tmp_dir, tag_version|
+            Command.run *%W[svn export -q --non-interactive #{SVN_TAGS_URL}#{tag_version}/ #{tmp_dir}]
+            $?.success?
+          end
+        rescue SystemExit
+        end
+
+        def download_version_via_git_pull(version)
+          tmpdir_for_latest_version_from_tag_list(GIT_TAG_LIST_COMMAND, GIT_TAG_REGEXP, version) do |tmp_dir, tag_version|
+            tmp_dir.mkpath
+            Dir.chdir(tmp_dir) do
+              Command.run 'git init -q'
+              Command.run *%W[git pull -q --depth=1 #{GIT_URL} #{tag_version}]
+              (tmp_dir / '.git').rmtree
+            end
+            $?.success?
+          end
+        rescue SystemExit
+        end
+
+        def download_version_via_git_tarball(version)
+          if tag_version = latest_version_from_tag_list(GIT_TAG_LIST_COMMAND, GIT_TAG_REGEXP, version)
+            unless path_for_version(tag_version)
+              tempfile_for(sources_dir / "#{tag_version.dir_name}.tgz") do |f|
+                Command.run *%W[
+                  curl -L -s
+                  http://#{GIT_BARE_URL}/tarball/#{tag_version.to_s.split('/').last}
+                  -o #{f}
+                ]
+              end
+            end
+            path_for_version(tag_version)
+          end
+        rescue SystemExit
+        end
+      end
+    end
+  end
+end

data/lib/doc/configurator/ruby/stdlib.rb

@@ -0,0 +1,32 @@
+require 'net/http'
+require 'tempfile'
+require 'yaml'
+
+module Doc
+  class Configurator
+    class Ruby
+      module Stdlib
+        STDLIB_CONFIG_URL = 'http://stdlib-doc.rubyforge.org/svn/trunk/data/gendoc.yaml'
+
+        def stdlib_config(update)
+          if update || !read_stdlib_config
+            download_stdlib_config
+          end
+          read_stdlib_config
+        end
+
+        def stdlib_config_path
+          sources_dir / 'stdlib-config.yaml'
+        end
+
+        def read_stdlib_config
+          YAML.load_file stdlib_config_path if stdlib_config_path.readable?
+        end
+
+        def download_stdlib_config
+          stdlib_config_path.write(Net::HTTP.get(URI.parse(STDLIB_CONFIG_URL)))
+        end
+      end
+    end
+  end
+end

data/lib/doc/configurator/ruby/version_specifier.rb

@@ -0,0 +1,39 @@
+module Doc
+  class Configurator
+    class Ruby
+      class VersionSpecifier
+        attr_reader :str, :parts
+        alias_method :to_s, :str
+        def initialize(o)
+          @str = o.to_s
+          @parts = str.scan(/\d+/).map(&:to_i)
+        end
+
+        def valid?
+          str =~ /^\d+\.\d+(?:\.\d+(?:-p\d+)?)?$/
+        end
+
+        def full_version?
+          valid? && parts.length == 4
+        end
+
+        def dir_name
+          'ruby-%d.%d.%d-p%d' % parts
+        end
+
+        include Comparable
+        def <=>(other)
+          parts <=> other.parts
+        end
+
+        def ===(other)
+          if other.respond_to?(:parts)
+            parts == other.parts[0, parts.length]
+          else
+            str === other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doc/core_ext.rb

@@ -0,0 +1,75 @@
+require 'fspath'
+
+def glob_require(*globs)
+  globs.each do |glob|
+    $LOAD_PATH.each do |load_dir|
+      FSPath.glob(File.join(load_dir, glob)).each do |path|
+        require path.relative_path_from(FSPath(load_dir)).to_s
+      end
+    end
+  end
+end
+
+class Integer
+  def minutes
+    60 * self
+  end
+  alias_method :minute, :minutes
+
+  def hours
+    60 * minutes
+  end
+  alias_method :hour, :hours
+
+  def days
+    24 * hours
+  end
+  alias_method :day, :days
+
+  def weeks
+    7 * days
+  end
+  alias_method :week, :weeks
+end
+
+class String
+  def underscore
+    split(/::/).map{ |part| part.split(/(?=[A-Z])/).join('_') }.join('/').downcase
+  end
+end
+
+class Module
+  def smart_autoload(*names)
+    names.each do |name|
+      autoload name, "#{self}::#{name}".underscore
+    end
+  end
+
+  def abstract_method(*names)
+    names.each do |name|
+      class_eval <<-RUBY, __FILE__, __LINE__
+        def #{name}(*_)
+          raise NotImplementedError.new("\#{self.class.name} has no implementation for method `#{name}`")
+        end
+      RUBY
+    end
+  end
+end
+
+class Array
+  def select!(&block)
+    replace(select(&block))
+  end
+end
+
+class FSPath
+  def touch(atime = nil, mtime = nil)
+    open('w'){} unless exist?
+    utime(atime ||= Time.now, mtime || atime)
+  end
+
+  def rmtree_verbose
+    require 'fileutils'
+    FileUtils.rm_r(@path, :verbose => true)
+  end
+end

data/lib/doc/documentor.rb

@@ -0,0 +1,62 @@
+require 'fspath'
+require 'progress'
+
+module Doc
+  class Documentor
+    attr_reader :title, :min_update_interval, :clean_after, :configurators
+    attr_reader :base_dir, :sources_dir, :docs_dir, :public_dir
+    def initialize(*arguments, &block)
+      config = RootConfig.new(self, *arguments, &block)
+      config.check_options!([], [:title, :min_update_interval, :clean_after, :public_dir])
+
+      @title = config[:title] || 'ruby documentation'
+      @min_update_interval = config[:min_update_interval] || 1.hour
+      @clean_after = config[:clean_after]
+      @configurators = config.configurators
+
+      @base_dir = FSPath('.').expand_path
+      @sources_dir = base_dir / 'sources'
+      @docs_dir = base_dir / 'docs'
+      if config[:public_dir]
+        config[:public_dir] = FSPath(config[:public_dir]).cleanpath.to_s
+        if config[:public_dir] == '.'
+          raise ConfigError.new(self, "can't use base dir: #{config[:public_dir].inspect}")
+        end
+        if config[:public_dir].split(FSPath::SEPARATOR_PAT).include?('..')
+          raise ConfigError.new(self, ".. in public_dir: #{config[:public_dir].inspect}")
+        end
+      end
+      @public_dir = base_dir / (config[:public_dir] || 'public')
+    end
+
+    def config(update = false)
+      last_updated_path = base_dir / '.last_updated'
+      update ||= last_updated_path.exist? ? (Time.now > last_updated_path.mtime + min_update_interval) : true
+
+      configurators.with_progress('config/update').each do |configurator|
+        configurator.configure(update)
+      end
+      last_updated_path.touch if update
+
+      RootMerger.new(self, {
+        :title => title,
+        :tasks => configurators.with_progress('tasks').map(&:tasks).flatten
+      })
+    end
+
+    def build(update = false)
+      started = Time.now
+      root_task = config(update)
+
+      root_task.run
+
+      if clean_after
+        (sources_dir.directory? ? sources_dir.children : [] + docs_dir.children).each do |dir|
+          if started - dir.mtime > clean_after
+            dir.rmtree_verbose
+          end
+        end
+      end
+    end
+  end
+end