autoproj 1.0.0

data/doc/guide/config.yaml

@@ -0,0 +1,30 @@
+# This is the YAML configuration file for webgen used to set configuration options.
+#
+# The general syntax is:
+#
+#   configuration.option.name: value
+#
+# For example, to set a different default language, you would do:
+#
+#   website.lang: de
+#
+# Have a look at the documentation of the individual configuration options to see
+# the allowed format of the values. Since this is a YAML file, you can easily set
+# configuration options to strings, integers, dates, arrays, hashes and more.
+#
+# The available configuration options can be listed using the `webgen config`
+# command, for example: `webgen config sourcehandler` will list all options starting
+# with sourcehandler.
+default_processing_pipeline:
+    Page: tags,maruku,blocks
+
+default_meta_info:
+    Webgen::SourceHandler::Page:
+        in_menu: true
+
+tag.menu.nested: false
+
+tag.breadcrumbtrail.omit_index_path: true
+
+tag.coderay.line_numbers: false
+tag.coderay.lang: ruby

data/doc/guide/ext/init.rb

@@ -0,0 +1,17 @@
+# = webgen extensions directory
+#
+# All init.rb files anywhere under this directory get automatically loaded on a webgen run. This
+# allows you to add your own extensions to webgen or to modify webgen's core!
+#
+# If you don't need this feature you can savely delete this file and the directory in which it is!
+#
+# The +config+ variable below can be used to access the Webgen::Configuration object for the current
+# website.
+config = Webgen::WebsiteAccess.website.config
+
+config = Webgen::WebsiteAccess.website.config
+config['sourcehandler.patterns']['Webgen::SourceHandler::Copy'] << '**/autoproj_bootstrap'
+
+$LOAD_PATH.unshift File.expand_path('..', File.dirname(__FILE__))
+require 'ext/rdoc_links'
+require 'ext/previous_next'

data/doc/guide/ext/previous_next.rb

@@ -0,0 +1,40 @@
+require 'webgen/tag'
+class PrevNextTag
+    include Webgen::Tag::Base
+
+    def call(tag, body, context)
+        node = context.content_node
+        while !node.is_file?
+            node = node.parent
+        end
+
+        siblings = node.parent.children.sort
+        siblings.delete_if { |n| !n.meta_info['in_menu'] }
+        prev, _ = siblings.
+            enum_for(:each_cons, 2).
+            find { |prev, this| this == node }
+        _, nxt = siblings.
+            enum_for(:each_cons, 2).
+            find { |this, nxt| this == node }
+
+        content = if tag == "next" && nxt
+                      node.link_to(nxt)
+                  elsif tag == "previous" && prev
+                      node.link_to(prev)
+                  end
+
+        if content
+            if !body.empty?
+                body.gsub '%', content
+            else
+                content
+            end
+        end
+    end
+end
+
+config = Webgen::WebsiteAccess.website.config
+config['contentprocessor.tags.map']['previous'] = 'PrevNextTag'
+config['contentprocessor.tags.map']['next'] = 'PrevNextTag'
+
+

data/doc/guide/ext/rdoc_links.rb

@@ -0,0 +1,33 @@
+require 'webgen/tag'
+class RdocLinks
+    include Webgen::Tag::Base
+
+    def call(tag, body, context)
+        name = param('rdoclinks.name')
+        if base_module = param('rdoclinks.base_module')
+            name = base_module + "::" + name
+        end
+
+        if name =~ /(?:\.|#)(\w+)$/
+            class_name  = $` 
+            method_name = $1
+        else
+            class_name = name
+        end
+
+        path = class_name.split('::')
+        path[-1] += ".html"
+        url = "#{param('rdoclinks.base_url')}/#{path.join("/")}"
+
+        "<a href=\"#{context.ref_node.route_to(url)}\">#{param('rdoclinks.name')}</a>"
+    end
+end
+
+config = Webgen::WebsiteAccess.website.config
+config.rdoclinks.name        "", :mandatory => 'default'
+config.rdoclinks.base_webgen "", :mandatory => false
+config.rdoclinks.base_url    "", :mandatory => false
+config.rdoclinks.base_module nil, :mandatory => false
+config.rdoclinks.full_name   false, :mandatory => false
+config['contentprocessor.tags.map']['rdoc_class'] = 'RdocLinks'
+

data/doc/guide/src/autobuild.page

@@ -0,0 +1,111 @@
+---
+title: Writing autobuild scripts
+sort_info: 200
+---
+
+Defining CMake packages
+-----------------------
+A simple cmake package is defined with
+
+{coderay:: ruby}
+cmake_package "package_name"
+{coderay}
+
+More complex tweaking is achieved with
+
+{coderay:: ruby}
+cmake_package "package_name" do |pkg|
+  [modify the pkg object]
+end
+{coderay}
+
+In particular, cmake build options can be given with
+
+{coderay:: ruby}
+cmake_package "package_name" do |pkg|
+  pkg.define "VAR", "VALUE"
+end
+{coderay}
+
+The above snippet being equivalent to calling <tt>cmake -DVAR=VALUE</tt>
+
+<b>Note to advanced users</b>
+<br />
+The "pkg" variable holds an object that represents the package. This
+object is an instance of the Autobuild::CMake. See [the autobuild
+API](http://doudou.github.com/autobuild/Autobuild/CMake.html) for more
+details.
+{.note}
+
+Defining autotools packages
+---------------------------
+TBD
+
+Declaring documentation targets
+-------------------------------
+Both autotools and cmake packages use <tt>make</tt> as the low-level build tool.
+For both packages, you can declare a documentation target that will be used
+during the call to <tt>autoproj doc</tt> to generate documentation:
+
+{coderay:: ruby}
+cmake_package "package_name" do |pkg|
+  pkg.with_doc 'doc'
+  pkg.doc_dir = "doc/html"
+end
+{coderay}
+
+The doc\_dir assignment above is needed if the package installs its documentation
+elsewhere than "doc".
+
+Defining dependencies
+---------------------
+Inter-package dependencies can be defined with
+
+{coderay:: ruby}
+pkg.depends_on "package_name"
+{coderay}
+
+In the same way, if the source package depends on an OS package (see
+[Prepackaged dependencies](os_deps.html) for details), you can use
+
+{coderay:: ruby}
+pkg.depends_on_os_package "package_name"
+{coderay}
+
+Both methods should be used only for dynamic dependencies, i.e. dependencies
+that are dependent on build options (see below). Static dependencies should be
+defined in the package's manifest.xml
+{.warning}
+
+Defining and using options
+--------------------------
+
+It is possible to define configuration options which are set by your user at
+build time. These options can then be used in the autobuild scripts to
+parametrize the build.
+
+The general form of an option declaration is:
+
+{coderay:: ruby}
+configuration_option "option_name", "option_type",
+    :default => "default_value",
+    :values => ["set", "of", "possible", "values"],
+    :doc => "description of the option"
+{coderay}
+
+Once declared, it can be used in autobuild scripts with:
+
+{coderay:: ruby}
+user_config("option_name")
+{coderay}
+
+Options are saved in <tt>autoproj/config.yml</tt> after the build. Options that
+are already set won't be asked again unless the <tt>--reconfigure</tt> option is
+given to <tt>autoproj build</tt>.
+
+Do not try to have too many options, that is in general bad policy as
+non-advanced users won't be able to know what to answer. Advanced users will
+always have the option to override your autobuild definitions to tweak the
+builds to their needs.
+{.warning}
+

data/doc/guide/src/autoproj_bootstrap

@@ -0,0 +1,218 @@
+#! /usr/bin/ruby
+
+require 'yaml'
+require 'set'
+require 'rubygems'
+
+module Autoproj
+    class << self
+        attr_reader :verbose
+    end
+end
+
+module Autobuild
+    module Subprocess
+        def self.run(name, phase, *cmd)
+            `#{cmd.join(" ")}`
+            if $?.exitstatus != 0
+                STDERR.puts "ERROR: failed to run #{cmd.join(" ")}"
+                exit 1
+            end
+        end
+    end
+end
+
+require 'tempfile'
+module Autoproj
+    class OSDependencies
+        def self.load(file)
+            OSDependencies.new(YAML.load(File.read(file)))
+        end
+
+        attr_reader :definitions
+        def initialize(defs = Hash.new)
+            @definitions = defs.to_hash
+        end
+
+        def merge(info)
+            @definitions = definitions.merge(info.definitions)
+        end
+
+        def operating_system
+            if File.exists?('/etc/debian_version')
+                codename = File.read('/etc/debian_version').chomp
+                ['debian', codename]
+            else
+                raise ConfigError, "Unknown operating system"
+            end
+        end
+
+        GAIN_ROOT_ACCESS = <<-EOSCRIPT
+        if test `id -u` != "0"; then
+            exec sudo /bin/bash $0 "$@"
+        
+        fi
+        EOSCRIPT
+
+        OS_PACKAGE_INSTALL = {
+            'debian' => 'apt-get install -y %s'
+        }
+
+        def generate_os_script(dependencies)
+            os_name, os_version = operating_system
+            shell_snippets = ""
+            os_packages    = []
+            dependencies.each do |name|
+                dep_def = definitions[name]
+                if !dep_def
+                    raise ConfigError, "I don't know how to install '#{name}'"
+                elsif !dep_def[os_name]
+                    raise ConfigError, "I don't know how to install '#{name}' on #{os_name}"
+                end
+
+                data = dep_def[os_name]
+                if data.kind_of?(Hash)
+                    data = data[os_version]
+                    if !data
+                        raise ConfigError, "I don't know how to install '#{name}' on this specific version of #{os_name} (#{os_version})"
+                    end
+                end
+
+                if data.respond_to?(:to_ary)
+                    os_packages.concat data.to_ary
+                elsif data.to_str =~ /\w+/
+                    os_packages << data.to_str
+                else
+                    shell_snippets << "\n" << data << "\n"
+                end
+            end
+
+            "#! /bin/bash\n" +
+            GAIN_ROOT_ACCESS + "\n" +
+                (OS_PACKAGE_INSTALL[os_name] % [os_packages.join(" ")]) +
+                "\n" + shell_snippets
+        end
+
+        def partition_packages(package_set)
+            package_set = package_set.to_set
+            osdeps, gems = [], []
+            package_set.to_set.each do |name|
+                pkg_def = definitions[name]
+                if !pkg_def
+                    raise ConfigError, "I know nothing about a prepackaged '#{name}' software"
+                end
+
+                if pkg_def.respond_to?(:to_str)
+                    case(pkg_def.to_str)
+                    when "gem" then
+                        gems << name
+                    else
+                        raise ConfigError, "unknown OS-independent package management type #{pkg_def}"
+                    end
+                else
+                    osdeps << name
+                end
+            end
+            return osdeps, gems
+        end
+
+        def install(packages)
+            osdeps, gems = partition_packages(packages)
+
+            # Ideally, we would feed the OS dependencies to rosdep.
+            # Unfortunately, this is C++ code and I don't want to install the
+            # whole ROS stack just for rosdep ...
+            #
+            # So, for now, reimplement rosdep by ourselves. Given how things
+            # are done, this is actually not so hard.
+            shell_script = generate_os_script(osdeps)
+            if Autoproj.verbose
+                STDERR.puts "Installing non-ruby OS dependencies with"
+                STDERR.puts shell_script
+            end
+
+            File.open('osdeps.sh', 'w') do |file|
+                file.write shell_script
+            end
+            Autobuild::Subprocess.run 'autoproj', 'osdeps', 'bash', './osdeps.sh'
+            FileUtils.rm_f 'osdeps.sh'
+
+            # Don't install gems that are already there ...
+            gems.delete_if do |name|
+                version_requirements = Gem::Requirement.default
+                available = Gem.source_index.find_name(name, version_requirements)
+                !available.empty?
+            end
+
+            # Now install what is left
+            if !gems.empty?
+                if Autoproj.verbose
+                    STDERR.puts "Installing rubygems dependencies with"
+                    STDERR.puts "gem install #{gems.join(" ")}"
+                end
+                Autobuild::Subprocess.run 'autoproj', 'osdeps', 'gem', 'install', *gems
+            end
+        end
+    end
+end
+
+
+
+DEFS = <<EODEFS
+ruby:
+    debian: 
+        - ruby1.8-dev
+        - ruby1.8
+        - libopenssl-ruby1.8
+
+build-essential:
+    debian: build-essential
+
+libxml2:
+    debian:
+        - libxml2-dev
+libxslt:
+    debian:
+        - libxslt1-dev
+autoproj: gem
+EODEFS
+
+PACKAGES      = %w{ruby libxml2 libxslt build-essential}
+USER_PACKAGES = %w{autoproj}
+
+packages = PACKAGES.dup
+if ARGV.first != "dev"
+    packages += USER_PACKAGES
+end
+
+osdeps_management = Autoproj::OSDependencies.new(YAML.load(DEFS))
+STDERR.puts "autoproj: installing autoproj and its dependencies (this can take a long time)"
+osdeps_management.install(packages)
+
+if ARGV.first != "dev"
+    ENV['RUBYOPT']  = "-rubygems"
+    ENV['GEM_HOME'] = "#{Dir.pwd}/autoproj/gems"
+    ENV['PATH']     = "#{ENV['GEM_HOME']}/bin:$PATH"
+    Autobuild::Subprocess.run('bootstrap', 'post', 'autoproj', 'bootstrap')
+end
+
+File.open('env.sh', 'w') do |io|
+    io.write <<-EOSHELL
+export RUBYOPT=-rubygems
+export GEM_HOME=#{Dir.pwd}/autoproj/gems
+export PATH=$GEM_HOME/bin:$PATH
+    EOSHELL
+end
+
+STDERR.puts <<EOTEXT
+
+
+add the following line at the bottom of your .bashrc:
+  source #{Dir.pwd}/env.sh
+
+WARNING: autoproj will not work until your restart all
+your consoles, or run the following in them:
+  $ source #{Dir.pwd}/env.sh
+
+EOTEXT
+