build-tool 0.0.3 → 0.1.0

data/lib/build-tool/commands/recipes/install.rb

@@ -0,0 +1,184 @@
+require 'build-tool/application'
+require 'build-tool/commands'
+require 'ftools'
+
+module BuildTool; module Commands; module Recipes
+
+    #
+    # BuildCommand
+    #
+    class Install < Standard
+
+        name        "install"
+        description "install a build recipe"
+
+        def initialize_options
+            super
+        end
+
+        def do_execute(args)
+
+            require 'build-tool/GUI'
+
+            # Check parameters
+            if args.length < 1 or args.length > 2
+                return usage("Wrong number of arguments")
+            end
+
+            # First param is recipename
+            recipename = args[0]
+            # Second optional parameter is command name
+            if args.length == 2
+                commandname = args[1]
+            else
+                commandname = args[0]
+            end
+            exename = "#{commandname}-build"
+            conffile = Application::instance.local_configuration_dir.join("#{commandname}.yaml")
+
+            # Our executable
+            buildtool = Application::instance.application_root.join( 'bin', 'build-tool' ).to_s
+
+            # Load the recipe
+            recipe = Recipe.find_recipe(recipename)
+            if !recipe
+                logger.error "Unknown recipe #{recipename}!"
+                return -1
+            end
+
+            say ""
+            say "Step 1)"
+            say "Add a symbolic link name '#{exename}' somewhere into your $PATH."
+
+            # Check if there are already commands with exename
+            existing = find_in_path( ENV['PATH'], exename )
+            found = false   # Was the link found?
+            existing.each do |exe|
+                if exe.exist?
+                    if exe.symlink? and File.identical? exe, buildtool
+                        found = true
+                    else
+                        logger.warn "Found another command named #{exename} at #{exe.to_s}"
+                    end
+                end
+            end
+
+            if found == true
+                say "The symlink already exists. Skipping this step"
+            else
+                dirs = find_writable_dirs( ENV['PATH'] )
+                dir = nil
+                if dirs.empty?
+                    logger.error "No writable directory found in $PATH. Please add one (usually $HOME/bin) or"
+                    logger.error "create a symbolic link in a directory that is part of $PATH yourself."
+                    logger.error "> ln -s #{buildtool} #{exename}"
+                elsif dirs.length == 1
+                    dir = dirs[0]
+                    say "Exactly one writeable directory found in your $PATH. Symbolic link will be"
+                    say "created in :#{dir}"
+                else
+                    if dirs.length > 1
+                        ( dir, index ) = Gem::DefaultUserInteraction.ui.choose_from_list(
+                            "More than one writeable directory found in $PATH. Which one should i use?", dirs)
+                    end
+                end
+                link = Pathname.new(dir).join(exename)
+                if link.exist?
+                    logger.error "Can not create the link because the 'to' already exists. Please create"
+                    logger.error "a symbolic link in a directory that is part of $PATH yourself."
+                    logger.error "> ln -s #{buildtool} #{exename}"
+                else
+                    File.symlink(buildtool, Pathname.new(dir).join(exename))
+                end
+            end
+
+            # Now write the settings file
+            say <<EOS
+
+Step 2)"
+Create a example configuration file. Please open the file in a editor and
+change it to your preferences. It is important to at least set LIB_SUFFIX and
+MAKEFLAGS to values your system needs or can handle.
+
+LIB_SUFFIX is either '64', '32' or ''. Issue 'gcc -v' and search for
+--libdir=lib(64|32|).  Set LIB_SUFFIX accordingly. If you can't see --libdir
+set LIB_SUFFIX to "". Those information is only correct if you not use the
+   -m32                        Generate 32bit i386 code
+   -m64                        Generate 64bit x86-64 code
+gcc options.
+
+MAKEFLAGS can be used provide flags to the make command. The '-jN' options is
+used to parallelize the compiling. Set N to your the number of cpu cores+1 for
+a start.
+
+You will find the file at #{conffile.to_s}.
+EOS
+            if conffile.exist?
+                say "The config file already exists. Copying omitted."
+            else
+                File.copy(recipe.join("settings.yaml"), conffile)
+            end
+
+            say <<EOS
+
+Step 3)
+Creating a local configuration file you can use to change very aspect from the
+global configuration file, You will find it at 
+> #{Application::instance.local_configuration_dir.join( commandname, 'recipe' )}
+EOS
+            if File.exist?( Application::instance.local_configuration_dir.join(commandname))
+                logger.error( "Local configuration for #{commandname} already exists!" )
+            else
+                FileUtils.mkdir_p( Application::instance.local_configuration_dir.join( commandname ) )
+                File.copy(recipe.join("recipe-local"),
+                          Application::instance.local_configuration_dir.join( commandname, 'recipe' ))
+            end
+
+            say <<EOS
+
+Step 4)
+You now can start to use your recipe. The first command to look at are:
+# Show the configuration
+> #{exename} info
+# Show all modules
+> #{exename} module list
+# Show detailed info for a module
+> #{exename} module info <module>
+# Build a module (-u = enable updating)
+> #{exename} build -u <module>
+EOS
+
+            # We were successful
+            return 0
+        end
+
+        def find_writable_dirs(path)
+            dirs = []
+            path.split(':').each do |dir|
+                dirhd = Pathname.new(dir)
+                if dirhd.directory? and dirhd.writable?
+                    dirs << dir
+                end
+            end
+            dirs
+        end
+
+        def find_in_path( path, name )
+            dirs = []
+            path.split(':').each do |dir|
+                hd = Pathname.new(dir).join(name)
+                if hd.exist?
+                    dirs << hd
+                end
+            end
+            dirs
+        end
+
+    end # class
+
+end; end # module Commands::Recipes
+
+end; # module BuildTool
+
+
+

data/lib/build-tool/commands/recipes/list.rb

@@ -0,0 +1,33 @@
+require 'build-tool/commands'
+require 'build-tool/recipe'
+
+module BuildTool; module Commands; module Recipes
+
+    #
+    # BuildCommand
+    #
+    class List < Standard
+
+        name        "list"
+        description "list build recipes"
+
+        def initialize_options
+            super
+        end
+
+        def do_execute( args )
+            recipes = Recipe.all_recipes
+            recipes.keys.sort.each do |name|
+                say format( "%-20s - %s", name, recipes[name].short_description )
+            end
+
+            return 0
+        end
+
+    end # class
+
+end; end # module Commands::Recipes
+
+end; # module BuildTool
+
+

data/lib/build-tool/configuration.rb

@@ -0,0 +1,115 @@
+require 'build-tool/vcs/git'
+require 'build-tool/vcs/git-svn'
+require 'build-tool/vcs/svn'
+
+require 'build-tool/build-system/cmake'
+require 'build-tool/build-system/qt'
+require 'build-tool/build-system/autoconf'
+require 'build-tool/build-system/custom'
+
+
+module BuildTool
+
+    class Configuration
+
+        attr_reader :recipe
+        attr_reader :modules
+        attr_reader :environments
+
+        def log_directory
+            return @log_directory if @log_directory
+            raise BuildTool::ConfigurationError, "No log directory configured"
+        end
+        def log_directory=( path )
+            @log_directory = File.expand_path( path, "~" );
+        end
+
+        def environment( name )
+            @environments[name]
+        end
+
+        def add_environment( env)
+            @environments[env.name] = env
+        end
+
+        def module( name )
+            @module[name]
+        end
+
+        def add_module( mod )
+            @module[mod.name] = mod
+            @modules << mod
+        end
+
+        def repository( name )
+            @repository[name]
+        end
+
+        def add_repository( repo )
+            @repository[repo.name] = repo
+        end
+
+        def server( name )
+            @server[name]
+        end
+
+        def add_server( server )
+            @server[ server.name ] = server
+        end
+
+        def sshkey( name )
+            @sshkey[name]
+        end
+
+        def add_sshkey( key )
+            @sshkey[key.name] = key
+        end
+
+        def initialize( recipe = nil )
+            @recipe = recipe
+            @server = {}
+            @log_directory = nil
+            @environments = {}
+            @module = {}
+            @modules = []
+            @build_system = {}
+            @repository = {}
+            @sshkey = {}
+        end
+
+        def vcs( name )
+            case name
+            when "git-svn"
+                return BuildTool::VCS::GitSvnConfiguration.new
+            when "git"
+                return BuildTool::VCS::GitConfiguration.new
+            when "svn"
+                return BuildTool::VCS::SvnConfiguration.new
+            else
+                raise StandardError, "Unknown Version Control System #{name}"
+            end
+        end
+
+        def build_system( name )
+            return @build_system[name] if @build_system[name]
+            case name
+            when "cmake"
+                return BuildTool::BuildSystem::CMake.new
+            when "qt"
+                return BuildTool::BuildSystem::Qt.new
+            when "qmake"
+                return BuildTool::BuildSystem::QMake.new
+            when "custom"
+                return BuildTool::BuildSystem::Custom.new
+            else
+                raise StandardError, "Unknown Version Control System #{name}"
+            end
+        end
+
+        def add_build_system( bs )
+            @build_system[bs.name] = bs
+        end
+
+    end # Configuration
+
+end # module BuildTool

data/lib/build-tool/environment.rb

@@ -0,0 +1,119 @@
+require 'mj/tools/subprocess'
+
+module BuildTool
+
+    #
+    # Encapsulates all environment related options for a build
+    #
+    class Environment
+
+        include MJ::Tools::SubProcess
+
+        # Name for the environment
+        attr_reader :name
+
+        # Parent environment
+        attr_accessor :parent
+
+        # Create a environment object
+        def initialize( name )
+            raise StandardError.new "Environment.name has to be set" if name.nil?
+            @name = name
+            @vars = Hash.new
+            @parent = nil
+        end
+
+        # Set a environment variable
+        def append( name, value )
+            if @vars.has_key?(name.to_s) and !@vars[name.to_s].empty?
+                @vars[name.to_s] = "#{@vars[name.to_s]}:#{value.to_s}"
+            else
+                set( name, "$#{name.to_s}:#{value}" )
+            end
+        end
+
+        # Execute command in a shell with the environment set.
+        def execute( command, wd = nil )
+            rc = self.class.execute( command.to_s, wd, values )
+            if rc != 0
+                raise StandardError, "#{command.to_s} failed with error code #{rc}";
+            end
+            rc
+        end
+
+        # Prepend +value+ to variable +name+. A ':' is added when necessary.
+        def prepend( name, value )
+            if @vars.has_key?(name.to_s) and !@vars[name.to_s].empty?
+                @vars[name.to_s] = "#{value.to_s}:#{@vars[name.to_s]}"
+            else
+                set( name, "#{value}:$#{name.to_s}" )
+            end
+        end
+
+        def set( name, value )
+            @vars[name.to_s] = value.to_s
+        end
+
+        # Open a shell with the environment set.
+        #
+        # It sets an environment variable *BUILD_TOOL_ENV* with the name of
+        # the environment set. This can be used to add this information to
+        # the prompt.
+        def shell( wd = nil )
+            begin
+                ENV['JAM_PROJECT'] = name
+                self.class.adjust_environment( wd, values ) {
+                    logger.info "Starting #{ENV['SHELL']}"
+                    system( ENV['SHELL'] )
+                    logger.info "#{ENV['SHELL']} stopped."
+                    return 0;
+                }
+            ensure
+                ENV['JAM_PROJECT'] = nil
+            end
+        end
+
+        def vars
+            if @parent
+                ( @vars.keys + @parent.vars ).uniq
+            else
+                @vars.keys
+            end
+        end
+
+        def values
+            vals = {}
+            vars.each do |var|
+                vals[var] = self[var]
+            end
+            vals
+        end
+
+        # Get the value of a environment variable
+        def []( name )
+            parentval = ""
+            # Get the value from the parent
+            if @parent
+                parentval = @parent[name]
+            end
+            # If we don't know the var return the parents value
+            if !@vars.has_key?( name.to_s )
+                return parentval
+            end
+            if parentval.empty?
+                val = @vars[name.to_s].sub( ":$#{name.to_s}:", "" )
+                val.sub!( ":$#{name.to_s}", "" )
+                val.sub!( "$#{name.to_s}:", "" )
+                return val
+            else
+                return @vars[name.to_s].sub( "$#{name.to_s}", parentval )
+            end
+        end
+
+        def to_s
+            "Environment: #{name}"
+        end
+
+    end # class Environment
+
+end # module BuildTool