RubyGems - rubu - Versions diffs - 0.0.1 - Mend

rubu 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

checksums.yaml +7 -0
data/CHANGELOG.rdoc +3 -0
data/LICENSE +20 -0
data/README.rdoc +63 -0
data/doc/Array.html +422 -0
data/doc/Rubu.html +201 -0
data/doc/Rubu/Action.html +1002 -0
data/doc/Rubu/AlwaysBuild.html +275 -0
data/doc/Rubu/Build.html +1663 -0
data/doc/Rubu/DateBuild.html +275 -0
data/doc/Rubu/Flow.html +893 -0
data/doc/Rubu/FlowRun.html +377 -0
data/doc/Rubu/Fork.html +253 -0
data/doc/Rubu/Info.html +264 -0
data/doc/Rubu/Mark.html +1375 -0
data/doc/Rubu/MarkBuild.html +275 -0
data/doc/Rubu/Order.html +264 -0
data/doc/Rubu/RubyCommand.html +315 -0
data/doc/Rubu/ShellCommand.html +333 -0
data/doc/Rubu/State.html +412 -0
data/doc/Rubu/Var.html +264 -0
data/doc/Rubu/Walk.html +184 -0
data/doc/_index.html +313 -0
data/doc/class_list.html +58 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +57 -0
data/doc/css/style.css +339 -0
data/doc/file.CHANGELOG.html +79 -0
data/doc/file.README.html +133 -0
data/doc/file_list.html +63 -0
data/doc/frames.html +26 -0
data/doc/index.html +133 -0
data/doc/js/app.js +219 -0
data/doc/js/full_list.js +181 -0
data/doc/js/jquery.js +4 -0
data/doc/method_list.html +549 -0
data/doc/top-level-namespace.html +114 -0
data/example/bin/gen_world +10 -0
data/example/bin/rubu_example +178 -0
data/example/runme +26 -0
data/example/src/hello_world.c +11 -0
data/lib/rubu.rb +790 -0
data/lib/version.rb +6 -0
metadata +92 -0

data/doc/top-level-namespace.html ADDED

@@ -0,0 +1,114 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.8.7.6
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  hasFrames = window.top.frames.main ? true : false;
+  relpath = '';
+  framesUrl = "frames.html#!top-level-namespace.html";
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div id="header">
+      <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
+</div>
+      <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+      Class List
+    </a>
+    <a class="full_list_link" id="method_list_link"
+        href="method_list.html">
+      Method List
+    </a>
+    <a class="full_list_link" id="file_list_link"
+        href="file_list.html">
+      File List
+    </a>
+</div>
+      <div class="clear"></div>
+    </div>
+    <iframe id="search_frame"></iframe>
+    <div id="content"><h1>Top Level Namespace
+</h1>
+<dl class="box">
+</dl>
+<div class="clear"></div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="Rubu.html" title="Rubu (module)">Rubu</a></span>
+      <strong class="classes">Classes:</strong> <span class='object_link'><a href="Array.html" title="Array (class)">Array</a></span>
+</p>
+</div>
+    <div id="footer">
+  Generated on Fri Jun 29 10:04:07 2018 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.8.7.6 (ruby-2.3.3).
+</div>
+  </body>
+</html>

data/example/bin/gen_world ADDED

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+IO.write( 'build/world.c', "\
+#include <stdio.h>
+void print_world( void )
+{
+    printf( \"World\" );
+}"
+    )

data/example/bin/rubu_example ADDED

@@ -0,0 +1,178 @@
+#!/usr/bin/env ruby
+require 'como'
+include Como
+require 'rubu'
+include Rubu
+require 'fileutils'
+Spec.command( 'rubu_example', 'Tero Isannainen', '2018',
+    [
+        [ :opt_multi, 'conf',    '-c', "Configuration option." ],
+        [ :switch,    'verbose', '-v', "Verbose." ],
+        [ :switch,    'serial',  '-s', "Serial execution." ],
+        [ :default,    nil,       nil, "Flow(s) to execute." ],
+    ] )
+# ------------------------------------------------------------
+# Build specific definitions:
+# Set flow related options.
+Var[ :bin_dir ]    = 'bin'
+Var[ :source_dir ] = 'src'
+Var[ :build_dir ]  = 'build'
+Var[ :exe_name ]   = 'build/hello'
+# Default for :fast option.
+Var[ :fast ] = false
+# Change Rubu to verbose mode.
+if Opt['verbose'].given
+    Order[ :verbose ] = true
+end
+# Read setup files and apply Como command line arguments to Var space.
+Flow.setup( :como => 'conf' )
+# ------------------------------------------------------------
+# Build Commands:
+# Code generator with generated file dependency.
+class GenWorld < MarkBuild
+    def build
+        shrun "bin/gen_world"
+    end
+end
+# Typical C compilation with GCC, from source to object.
+class GccCompileFile < DateBuild
+    def setup
+        @cmd = "gcc -Wall -I #{Var[:source_dir]} -c #{source.rpath} -o #{target.rpath}"
+        # Compile with "-O2" if :fast is set.
+        if Var[ :fast ]
+            @cmd += " -O2"
+        else
+            @cmd += " -g"
+        end
+    end
+    def build
+        shrun @cmd
+    end
+end
+# GCC linking.
+class GccLinkExe < DateBuild
+    def setup
+        @cmd  = "gcc #{sources.rpath} -o #{target.rpath}"
+    end
+    def build
+        shrun @cmd
+    end
+end
+# Cleaning.
+class CleanObjects < Build
+    def build
+        # Multiple jobs are grouped with walk (serial execution).
+        walk do
+            shdef "rm -f #{Info[ :gen_files ].rpath}"
+            shdef "rm -f #{Var[ :build_dir ]}/*.o"
+            # Use Ruby for deleting the exe as an example.
+            rbdef "rm -f #{Var[ :exe_name ]}" do
+                FileUtils.rm_f Var[ :exe_name ]
+            end
+        end
+    end
+end
+# ------------------------------------------------------------
+# Collect sources and create targets:
+# Generator file and the target.
+gen_file      = Mark.path( "#{Var[:bin_dir]}/gen_world" )
+gen_cee_file  = Mark.path( "#{Var[:build_dir]}/world.c" )
+# Collect "normal" C files.
+cee_files     = Mark.glob( "#{Var[:source_dir]}/*.c" )
+# Create list of all C files.
+all_cee_files = [ gen_cee_file ] + cee_files
+# Convert C files to corresponding Object files.
+obj_files     = all_cee_files.peer( Var[ :build_dir ], '.o' )
+# Specify executable file.
+exe_file      = Mark.path( Var[ :exe_name ] )
+# Generate execution time information to Info. Used by CleanObjects.
+Info[ :gen_files ] = [ gen_cee_file ]
+# ------------------------------------------------------------
+# Define flows:
+# Serial flow for code generation.
+Walk.form 'gen-cee' do
+    # Create GenWorld build and register it to 'gen-cee'.
+    GenWorld.use( gen_file, gen_cee_file )
+end
+# Parallel compilation of all C files.
+Fork.form 'compile-cee' do
+    # Create set of GCC builds by joining 'all_cee_files' and
+    # 'obj_files' in pairs.
+    GccCompileFile.usezip( all_cee_files, obj_files )
+end
+# Default flow, i.e. generate, compile, link to executable.
+Walk.form 'default' do
+    # Reference 'gen-cee' flow.
+    pick 'gen-cee'
+    # Reference 'compile-cee' flow.
+    pick 'compile-cee'
+    # Create GCC link build and register it.
+    GccLinkExe.use( obj_files, exe_file )
+end
+# Cleaner flow.
+Walk.form 'clean' do
+    CleanObjects.use
+end
+# ------------------------------------------------------------
+# Run selected flows:
+flows = nil
+if Opt[ nil ].given
+    flows = Opt[ nil ].value
+else
+    flows = [ 'default' ]
+end
+if Opt[ 'serial' ].given
+    Order[ :serial ] = true
+end
+Flow.run( flows )

data/example/runme ADDED

@@ -0,0 +1,26 @@
+#!/bin/sh
+echo "-- Starting with cleaning without any output from Build Program:"
+bin/rubu_example clean
+echo "-- The same with command outputs:"
+bin/rubu_example -v clean
+echo "-- Initial build with all files created:"
+bin/rubu_example -v default
+echo "-- Re-build using implicit \"default\" build, but no changes and thus no actions:"
+bin/rubu_example -v
+echo "-- Touch main source file, and re-building occurs (serial flow forced/selected):"
+touch src/hello_world.c
+bin/rubu_example -s -v
+echo "-- Touch file generator script, but no actions since building is file context sensitive only:"
+touch bin/gen_world
+bin/rubu_example -v
+echo "-- Complete re-build by combining clean and default build:"
+bin/rubu_example -v clean default

data/example/src/hello_world.c ADDED

@@ -0,0 +1,11 @@
+#include <stdio.h>
+void print_world( void );
+int main( int argc, char** argv )
+{
+    printf( "Hello " );
+    print_world();
+    printf( "!\n" );
+    return 0;
+}

data/lib/rubu.rb ADDED

@@ -0,0 +1,790 @@
+require 'open3'
+require 'yaml'
+require 'digest/md5'
+module Rubu
+    class State
+        @@md5 = {}
+        @@state_file = ".rubu_state.yml"
+        def State.save
+            if @@md5.any?
+                IO.write( @@state_file, YAML.dump( @@md5 ) )
+            end
+        end
+        def State.load
+            if File.exist?( @@state_file )
+                @@md5 = YAML.load_file( @@state_file )
+            end
+        end
+        def State.md5_gen( file )
+            Digest::MD5.hexdigest( File.read( file ) )
+        end
+        def State.md5_check_and_update?( file )
+            if @@md5[ file ]
+                md5 = State.md5_gen( file )
+                if md5 != @@md5[ file ]
+                    @@md5[ file ] = md5
+                    return true
+                end
+                return false
+            else
+                @@md5[ file ] = State.md5_gen( file )
+                return true
+            end
+        end
+    end
+    # Build activity.
+    class Action
+        @@host = []
+        # Status after execution.
+        attr_reader :status
+        # Storage for error message.
+        attr_reader :errmsg
+        # Command output.
+        attr_reader :output
+        # Sub actions.
+        attr_reader :subs
+        def initialize
+            @status = :success
+            @errmsg = nil
+            @output = nil
+            @subs = []
+        end
+        # Register Action to host (upper level).
+        def use
+            host.subs.push( self ) if host
+            self
+        end
+        # Take flow into use.
+        def pick( flow )
+            Flow[ flow ].use
+        end
+        # Push host.
+        def host_in
+            @@host.push self
+        end
+        # Pop host.
+        def host_out
+            @@host.pop
+        end
+        # Current host.
+        def host
+            @@host[-1]
+        end
+        # Report (and store) error.
+        def error( msg )
+            @errmsg = msg
+            STDERR.puts "Rubu Error: #{@errmsg}"
+        end
+        # Display command output.
+        def display( msg )
+            @output = msg
+            STDOUT.puts @output
+        end
+    end
+    # Shell based command.
+    class ShellCommand < Action
+        def initialize( cmd )
+            super()
+            @cmd = cmd
+        end
+        def run
+            begin
+                stdout, stderr, status = Open3.capture3( @cmd )
+                if Order[ :verbose ]
+                    STDOUT.puts @cmd
+                end
+                if status.exitstatus == 0
+                    @status = :success
+                else
+                    @status = :error
+                    error( stderr )
+                end
+            rescue
+                error( "Invalid command: \"#{@cmd}\"..." )
+                @status = :error
+            end
+            self
+        end
+    end
+    # Ruby based command.
+    class RubyCommand < Action
+        def initialize( desc = nil, &cmd )
+            super()
+            @desc = desc
+            @cmd = cmd
+        end
+        def run
+            begin
+                ret = instance_eval( &@cmd )
+                @status = :success
+                if @desc && Order[ :verbose ]
+                    STDOUT.puts @desc
+                end
+            rescue => f
+                @status = :error
+                error( f.backtrace.join("\n") )
+            end
+            self
+        end
+    end
+    # Flow execution methods.
+    module FlowRun
+        def serial_run
+            @subs.each do |sub|
+                sub.run
+                if sub.status == :error
+                    @status = :error
+                    @errmsg = sub.errmsg
+                    break
+                end
+            end
+            self
+        end
+        def parallel_run
+            if Order[ :serial ]
+                serial_run
+            else
+                if Order[ :parmax ] == 0 || @subs.length < Order[ :parmax ]
+                    ths = []
+                    @subs.each do |item|
+                        ths.push(
+                            Thread.new do
+                                item.run
+                            end
+                            )
+                    end
+                    ths.each do |th|
+                        th.join
+                    end
+                else
+                    cnt = @subs.length
+                    done = 0
+                    while done < cnt
+                        incr = Order[ :parmax ]
+                        if done >= cnt
+                            incr = done - cnt
+                        end
+                        ths = []
+                        incr.times do |i|
+                            item = @subs[ done+i ]
+                            ths.push(
+                                Thread.new do
+                                    item.run
+                                end
+                                )
+                        end
+                        ths.each do |th|
+                            th.join
+                        end
+                        done += incr
+                    end
+                end
+                @subs.each do |item|
+                    if item.status == :error
+                        @status = :error
+                        @errmsg = item.errmsg
+                        break
+                    end
+                end
+                self
+            end
+        end
+    end
+    # Source or Target file for build commands. Rubu handles only
+    # Marks, and hence bare file names are not usable.
+    class Mark
+        # Convert a list of file names to Marks.
+        def Mark.list( files )
+            unless files.kind_of? Array
+                files = [ files ]
+            end
+            files.map{ |file| Mark.path( file ) }
+        end
+        # Convert a list of file names matched with pattern to Marks.
+        def Mark.glob( pattern )
+            Mark.list( Dir.glob( pattern ) )
+        end
+        # Convert file path to Mark.
+        def Mark.path( file_path )
+            path = File.absolute_path( file_path )
+            dir = File.dirname( path ).split( '/' )
+            rdir = dir - Dir.pwd.split( '/' )
+            ext = File.extname( path )
+            base = File.basename( path, ext )
+            Mark.new( rdir, base, ext )
+        end
+        # Absolute directory.
+        attr_reader :dir
+        # Relative directory.
+        attr_reader :rdir
+        # Base name.
+        attr_reader :base
+        # File extension.
+        attr_reader :ext
+        # Skip file.
+        attr_accessor :skip
+        def initialize( rdir, base, ext )
+            if rdir.kind_of? Array
+                @dir = File.absolute_path( rdir.join( '/' ) ).split( '/' )
+                @rdir = rdir
+            else
+                @dir = File.absolute_path( rdir ).split( '/' )
+                @rdir = rdir.split( '/' )
+            end
+            @ext = ext
+            @base = base
+            @opt = {}
+            @skip = false
+        end
+        # Get options.
+        def []( key )
+            @opt[ key ]
+        end
+        # Set options.
+        def []=( key, val )
+            @opt[ key ] = val
+        end
+        # Set options.
+        def set_opt( key, val )
+            @opt[ key ] = val
+            self
+        end
+        # Return absolute path.
+        def path( ext = nil )
+            ext ||= @ext
+            "#{@dir.join('/')}/#{@base}#{ext}"
+        end
+        # Return relative path.
+        def rpath( ext = nil )
+            ext ||= @ext
+            "#{@rdir.join('/')}/#{@base}#{ext}"
+        end
+        # Return peer of Mark.
+        def peer( rdir, ext, base = nil )
+            base ||= @base
+            Mark.new( rdir, base, ext )
+        end
+        # Does Mark exist?
+        def exist?
+            File.exist?( path )
+        end
+        # Mark creation time.
+        def time
+            File.stat( path ).mtime
+        end
+    end
+    # Configuration space for Rubu.
+    class Order
+        @@order = {}
+        def Order.[]=( key, val )
+            @@order[ key ] = val
+        end
+        def Order.[]( key )
+            @@order[ key ]
+        end
+        # Order defaults:
+        # Force serial flow.
+        Order[ :serial ] = false
+        # Maximun parallel runs (0 for no limit).
+        Order[ :parmax ] = 0
+        # Verbose execution.
+        Order[ :verbose ] = false
+    end
+    # Option space for program.
+    class Var
+        @@var = {}
+        def Var.[]=( key, val )
+            @@var[ key ] = val
+        end
+        def Var.[]( key )
+            @@var[ key ]
+        end
+    end
+    # Information space for program.
+    class Info
+        @@info = {}
+        def Info.[]=( key, val )
+            @@info[ key ] = val
+        end
+        def Info.[]( key )
+            @@info[ key ]
+        end
+    end
+    # Build Action. Build Action takes one or more sources, and turns
+    # them into one or more targets.
+    class Build < Action
+        include FlowRun
+        # Create Action and register.
+        def self.use( sources = [], targets = [] )
+            self.new( sources, targets ).use
+        end
+        # Combine list of sources and targets to source/target pairs.
+        def self.zip( sources, targets )
+            sources.zip( targets ).map do |pair|
+                self.new( *pair )
+            end
+        end
+        # Combine list of sources and targets to source/target pairs
+        # and register.
+        def self.usezip( sources, targets )
+            sources.zip( targets ).map do |pair|
+                self.new( *pair ).use
+            end
+        end
+        attr_reader :sources
+        attr_reader :targets
+        def initialize( sources = [], targets = [] )
+            super()
+            unless sources.kind_of? Array
+                @sources = [ sources ]
+            else
+                @sources = sources
+            end
+            unless targets.kind_of? Array
+                @targets = [ targets ]
+            else
+                @targets = targets
+            end
+            setup
+        end
+        # Defined by users.
+        def setup
+        end
+        # Run Build Action and capture status.
+        def run
+            if update?
+                build
+            else
+                @status = :success
+            end
+            self
+        end
+        # Default update.
+        def update?
+            true
+        end
+        # Check for date (timestamp) based update needs.
+        def date_update?
+            # Check if targets are missing.
+            @targets.each do |target|
+                unless target.exist?
+                    return true
+                end
+            end
+            # Check if source(s) are newer than target(s).
+            newest_source = Time.new( 0 )
+            @sources.each do |source|
+                if source.time > newest_source && !source.skip
+                    newest_source = source.time
+                end
+            end
+            oldest_target = Time.now
+            @targets.each do |target|
+                if target.time < oldest_target
+                    oldest_target = target.time
+                end
+            end
+            return newest_source > oldest_target
+        end
+        # Check for mark (checksum) based update needs.
+        def mark_update?
+            unless date_update?
+                return false
+            end
+            # Check if targets are missing.
+            unless target.exist?
+                return true
+            end
+            old_verbose = Order[ :verbose ]
+            Order[ :verbose ] = false
+            build
+            Order[ :verbose ] = old_verbose
+            unless target.exist?
+                error "file generation failure"
+                exit false
+            end
+            unless State.md5_check_and_update?( target.rpath )
+                target.skip = true
+                return false
+            end
+            true
+        end
+        # Main (first) source file.
+        def source
+            @sources[0]
+        end
+        # Main (first) target file.
+        def target
+            @targets[0]
+        end
+        # Define and run Shell command.
+        def shrun( cmd )
+            ShellCommand.new( cmd ).run
+        end
+        # Define and register Shell command.
+        def shdef( cmd )
+            sh = ShellCommand.new( cmd )
+            sh.use
+        end
+        # Define and run Ruby command.
+        def rbrun( desc = nil, &cmd )
+            RubyCommand.new( desc, &cmd ).run
+        end
+        # Define and register Ruby command.
+        def rbdef( desc = nil, &cmd )
+            rb = RubyCommand.new( desc, &cmd )
+            rb.use
+        end
+        # Execute commands (in block) in parallel.
+        def fork( &blk )
+            host_in
+            instance_eval &blk
+            host_out
+            parallel_run
+        end
+        # Execute commands (in block) in series.
+        def walk( &blk )
+            host_in
+            instance_eval &blk
+            host_out
+            serial_run
+        end
+    end
+    # Uncondition build.
+    class AlwaysBuild < Build
+        def update?
+            true
+        end
+    end
+    # Date based build.
+    class DateBuild < Build
+        def update?
+            date_update?
+        end
+    end
+    # Mark based build.
+    class MarkBuild < Build
+        def update?
+            mark_update?
+        end
+    end
+    # Action Flow with name. Action Flow is a collection of build
+    # steps.
+    class Flow < Action
+        include FlowRun
+        # Flow hash.
+        @@flows = {}
+        # Replacement for new method.
+        def self.form( name = nil, &blk )
+            self.new( name, &blk )
+        end
+        # Reference Flow by name.
+        def self.[]( name )
+            @@flows[ name ]
+        end
+        attr_reader :name
+        def initialize( name = nil, &blk )
+            super()
+            @name = name
+            host_in
+            instance_eval &blk
+            host_out
+            if @name
+                @@flows[ @name ] = self
+            end
+        end
+        # Default run style for Flow.
+        def run
+            serial_run
+        end
+        def Flow.load_setup( setup )
+            if File.exist? setup
+                conf = YAML.load_file( setup )
+                conf.each do |k,v|
+                    scope = nil
+                    case k
+                    when :var; scope = Var
+                    when :order; scope = Order
+                    when :info; scope = Info
+                    end
+                    v.each do |k2,v2|
+                        scope[ k2 ] = v2
+                    end
+                end
+            end
+        end
+        # Apply configuration options if any.
+        def Flow.setup( spec )
+            load_setup( "#{ENV['HOME']}/.rubu.yml" )
+            load_setup( ENV['RUBU_CONF'] ) if ENV['RUBU_CONF']
+            load_setup( ".rubu.yml" )
+            State.load
+            # Apply options from Como.
+            if spec[ :como ]
+                como = spec[ :como ]
+                if Opt[ como ].given
+                    Opt[ como ].value.each do |conf|
+                        name, value = conf.split( '=' )
+                        value = case value
+                                when 'true'; true
+                                when 'false'; false
+                                else value
+                                end
+                        Var[ name.to_sym ] = value
+                    end
+                end
+            end
+        end
+        # Run selected flow(s).
+        def Flow.run( flows )
+            flows.each do |name|
+                begin
+                    ret = Flow[ name ].run
+                    if ret.status == :error
+                        STDERR.puts "Rubu FAILURE..."
+                        exit false
+                    end
+                rescue
+                    STDERR.puts "Broken flow: \"#{name}\"..."
+                    exit false
+                end
+            end
+            State.save
+            exit true
+        end
+    end
+    # Serial Flow.
+    class Walk < Flow; end
+    # Parallel Flow.
+    class Fork < Flow
+        def run
+            parallel_run
+        end
+    end
+end
+# Array class extension to support common Mark operations.
+class Array
+    def use
+        self.each do |item|
+            item.use
+        end
+    end
+    def set_opt( key, val )
+        self.each do |item|
+            item.set_opt( key, val )
+        end
+        self
+    end
+    def peer( rdir, ext, base = nil )
+        self.map do |item|
+            item.peer( rdir, ext, base )
+        end
+    end
+    def path( joiner = ' ' )
+        self.map{ |item| item.path }.join( joiner )
+    end
+    def rpath( joiner = ' ' )
+        self.map{ |item| item.rpath }.join( joiner )
+    end
+end