cxxproject 0.4.6 → 0.5.47

data/Rakefile.rb

@@ -1,69 +1,116 @@
-require 'rake/gempackagetask'
-begin
-  require 'roodi'
-  require 'roodi_task'
-rescue LoadError # don't bail out when people do not have roodi installed!
-  warn "roodi not installed...will not be checked!"
-end
-
-begin
-  require 'spec/rake/spectask' # old rspec
-rescue LoadError
-  begin
-		require 'rspec/core/rake_task' # rspec 2.5.x
-  rescue LoadError
-    warn "spec not installed...will not be checked!"
-  end
-end
-
-
+require 'rake/clean'
+require './rake_helper/spec.rb'
 
 desc "Default Task"
 task :default => [:install]
 
-PKG_FILES = FileList[
-  'lib/**/*.rb',
-  'lib/tools/**/*.template',
-  'Rakefile.rb',
-  'spec/**/*.rb'
-]
 
-task :gem
-spec = Gem::Specification.load('cxx.gemspec')
-Rake::GemPackageTask.new(spec)
+begin
+  require 'rubygems/package_task'
+  spec = Gem::Specification.load('cxx.gemspec')
+  Gem::PackageTask.new(spec){|pkg|}
+
+  desc "install gem globally"
+  task :install => [:gem] do
+    sh "gem install pkg/#{spec.name}-#{spec.version}.gem"
+  end
 
-if self.class.const_defined?(:RoodiTask) then
-  RoodiTask.new  'roodi', PKG_FILES, 'roodi.yml'
-  task :gem => [:roodi]
-end
 
-# old rspec
-if self.class.const_defined?(:SpecTask) then
-  desc "Run all examples"
-  Spec::Rake::SpecTask.new() do |t|
-    t.spec_files = FileList['spec/**/*_spec.rb']
+  begin
+    require 'rdoc'
+    require 'rdoc/task'
+    RDoc::Task.new do |rd|
+      rd.rdoc_files.include(spec.files)
+    end
+  rescue LoadError => e
+    task :rdoc do
+      puts 'please gem install rdoc'
+    end
   end
-#  task :gem => [:spec]
+  begin
+    require 'roodi'
+    require 'roodi_task'
+    class RoodiTask
+      def define
+        # copied from roodi_task.rb
+        desc "Check for design issues in: #{patterns.join(', ')}"
+        task name do
+          runner = Roodi::Core::Runner.new
+          runner.config = config if config
+          patterns.each do |pattern|
+            Dir.glob(pattern).each { |file| runner.check_file(file) }
+          end
+          runner.errors.each {|error| puts error}
+          # raise "Found #{runner.errors.size} errors." unless runner.errors.empty?
+        end
+        self
+      end
+    end
+    RoodiTask.new('roodi', spec.files)
+    task :gem => [:roodi]
+  rescue LoadError # don't bail out when people do not have roodi installed!
+      puts 'please gem install roodi'
+  end
+rescue LoadError => e
+    puts "please missing gems #{e}" 
 end
 
-# new rspec
-begin # const_defined? did not work?
-  desc "Run all examples"
-  RSpec::Core::RakeTask.new() do |t|
-    puts Dir.glob 'spec/**/*_spec.rb'
-    t.pattern = 'spec/**/*_spec.rb'
+def two_digits(x)
+  if x.length > 1
+    x
+  else
+    "0#{x}"
   end
-#  task :gem => [:spec]
-rescue
 end
 
-desc 'build gem only'
-task :gem_only do
-  sh "gem build cxx.gemspec"
-  mv FileList["*.gem"], "pkg"
-end
+begin
+  require 'grit'
+  include Grit
 
-desc "install gem globally"
-task :install => [:gem] do
-  sh "gem install pkg/#{spec.name}-#{spec.version}.gem"
+  def git_history      
+    repo = Repo.new('.')
+    tag_names = repo.tags.collect {|t| t.name }
+    relevant_tags = repo.tags.reject {|t| !t.name.start_with?("v_")}
+    sorted_tags = relevant_tags.sort_by.each do |t|
+      /v_(?<x>\d+)\.(?<y>\d+)\.(?<z>\d+)/ =~ t.name
+      "#{two_digits(x)}-#{two_digits(y)}-#{two_digits(z)}"
+    end
+
+    change_text = []
+    zipped = sorted_tags[0..-2].zip(sorted_tags[1..-1])
+    zipped.reverse.each do |a,b|
+      change_text << ""
+      change_text << "#{a.name} => #{b.name}"
+      change_text << ""
+      cs = repo.commits_between(a.commit, b.commit)
+      cm = cs.each do |c| 
+        change_lines = c.message.lines.to_a
+        first = change_lines.first
+        change_text << "    * " + first + "#{change_lines[1..-1].collect {|l| "      #{l}"}.join("")}"
+      end
+    end
+    change_text
+  end
+      
+  desc 'generate version history'
+  task :generate_history do
+    puts git_history
+  end
+
+  desc 'generate and update version history'
+  task :update_version_history do
+    change_line = "## Change History:"
+    readme = 'README.md'
+    content = File.read(readme)
+    File.open(readme, 'w') do |f|
+      f.puts content.gsub(/^#{change_line}.*/m, ([change_line] << git_history).join("\n"))
+    end
+  end
+
+rescue LoadError => e
+  puts 'to build the version history please gem install grit'
 end
+
+
+require './rake_helper/perftools'
+

data/bin/cxx

@@ -1,10 +1,10 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 $:.unshift File.join(File.dirname(__FILE__),"..","lib")
 
-require 'tools/projectWizard'
+require 'tools/project_wizard'
 
-if ARGV.size < 1 
-	puts "usage: cxx project-dir" 
+if ARGV.size < 1
+	puts "usage: cxx project-dir"
 	exit 0
 end
 prepare_project(ARGV[0])

data/lib/cxxproject/buildingblocks/binary_library.rb

@@ -1,16 +1,39 @@
 require 'cxxproject/buildingblocks/building_block'
 require 'cxxproject/buildingblocks/has_libraries_mixin'
+require 'cxxproject/buildingblocks/has_includes_mixin'
 
-class BinaryLibrary < BuildingBlock
-  include HasLibraries
+module Cxxproject
 
-  def initialize(name)
-    super(name)
-    libs_to_search << name
-  end
+  class BinaryLibrary < BuildingBlock
+    include HasLibraries
+    include HasIncludes
 
-  def get_task_name()
-    libs_to_search[0]
-  end
+    def initialize(name, useNameAsLib = true)
+      super(name)
+      if useNameAsLib
+        @useNameAsLib = name
+        add_lib_element(HasLibraries::LIB, name, true)
+      else
+        @useNameAsLib = nil
+      end
+    end
+
+    def get_task_name()
+      return @useNameAsLib if @useNameAsLib
+      @name
+    end
 
+
+    def convert_to_rake()
+      res = task get_task_name
+      def res.needed?
+        return false
+      end
+      res.transparent_timestamp = true
+      res.type = Rake::Task::BINARY
+      setup_rake_dependencies(res)
+      res
+    end
+
+  end
 end

data/lib/cxxproject/buildingblocks/building_block.rb

@@ -1,93 +1,239 @@
 require 'cxxproject/buildingblocks/has_dependencies_mixin'
-require 'cxxproject/utils/dot/graph_writer'
+require 'cxxproject/utils/exit_helper'
+require 'cxxproject/ext/rake'
+require 'cxxproject/ext/file'
+require 'cxxproject/ide_interface'
+require 'cxxproject/utils/printer'
 
-# stores all defined buildingblocks by name (the name should be unique)
-ALL_BUILDING_BLOCKS = {}
+# no deprecated warning for rake >= 0.9.x
+include Rake::DSL if defined?(Rake::DSL)
+module Cxxproject
 
-class BuildingBlock
-  include HasDependencies
+  # stores all defined buildingblocks by name (the name should be unique)
+  ALL_BUILDING_BLOCKS = {}
 
-  attr_reader :name
-  attr_reader :graph_name
-  attr_reader :config_files
-  attr_reader :project_dir
-  attr_reader :output_dir
-  attr_reader :complete_output_dir
-
-  def set_name(x)
-    @name = x
-    self
+  trap("INT") do
+    Rake.application.idei.set_abort(true)
   end
 
-  def set_tcs(x)
-    @tcs = x
-    self
-  end
-  
-  def has_tcs?
-    @tcs != nil
-  end
+  class BuildingBlock
+    include HasDependencies
 
-  def tcs()
-    raise "Toolchain settings must be set before!" if @tcs.nil?
-    @tcs
-  end
+    attr_reader :name
+    attr_reader :config_name
+    attr_reader :config_files
 
-  def set_config_files(x)
-    @config_files = x
-    self
-  end
+    attr_reader :project_dir
+    attr_accessor :output_dir
+    attr_accessor :pre_step
+    attr_reader :output_dir_abs
 
-  def set_project_dir(x)
-    @project_dir = x
-    calc_complete_output_dir
-    self
-  end
+    def set_name(x)
+      @name = x
+      self
+    end
 
-  # if output dir is absolute, -L and -l is used for linker ("linux mode")
-  def set_output_dir(x)
-    @output_dir = x
-    @output_dir_abs = File.is_absolute?(@output_dir)
-    calc_complete_output_dir
-    self
-  end
+    def set_tcs(x)
+      @tcs = x
+      self
+    end
 
-  def calc_complete_output_dir
-    if @output_dir_abs
-      @complete_output_dir = @output_dir
-    else
-      @complete_output_dir = @project_dir + "/" + @output_dir
+    def has_tcs?
+      @tcs != nil
     end
-  end
 
-  def set_graph_name(x)
-    @graph_name = x
-    self
-  end
+    def tcs()
+      raise "Toolchain settings must be set before!" if @tcs.nil?
+      @tcs
+    end
 
-  def initialize(name)
-    @name = name
-    @graph_name = name
-    @config_files = []
-    @project_dir = "."
-    @output_dir = "."
-    @complete_output_dir = "."
-    @tcs = nil
-    @output_dir_abs = false
-
-    begin
-      raise "building block already exists: #{name}" if ALL_BUILDING_BLOCKS.include?@name
-      ALL_BUILDING_BLOCKS[@name] = self
-    rescue Exception => e 
-      puts e
+    def set_config_files(x)
+      @config_files = x
+      @config_date = Time.now
+      self
     end
-  end
 
-  def complete_init()
-  end
+    def set_project_dir(x)
+      @project_dir = File.expand_path(x)
+      if @output_dir_abs
+        @output_dir_relPath = File.rel_from_to_project(@project_dir, @output_dir)
+      end
+      self
+    end
 
-  def get_task_name()
-    raise "this method must be implemented by decendants"
-  end
+    # if output dir is absolute, -L and -l is used for linker ("linux mode")
+    def set_output_dir(x)
+      return self if @output_dir
+
+      @output_dir = x
+      @output_dir_abs = File.is_absolute?(@output_dir)
+      if @project_dir
+        @output_dir_relPath = File.rel_from_to_project(@project_dir, @output_dir)
+      end
+      self
+    end
+
+    def complete_output_dir
+      @complete_output_dir ||= calc_complete_output_dir
+    end
+
+    def calc_complete_output_dir
+      if @output_dir_abs
+        @output_dir
+      else
+        File.join(@project_dir,  @output_dir)
+      end
+    end
+
+    def initialize(name)
+      @name = name
+      @config_name = nil
+      @config_files = []
+      @config_date = nil
+      @project_dir = nil
+      @tcs = nil
+      @output_dir = nil
+      @output_dir_abs = false
+      @complete_output_dir = nil
+      @pre_step = nil
+
+      if ALL_BUILDING_BLOCKS.include?(@name) and not self.instance_of?(BinaryLibrary)
+        raise "building block already exists: #{name}"
+      else
+        ALL_BUILDING_BLOCKS[@name] = self
+      end
+    end
+    
+    def set_config_name(x)
+      @config_name = x
+    end
+
+    def complete_init()
+      if self.respond_to?(:calc_compiler_strings)
+        calc_compiler_strings
+      end
+    end
+
+    def get_task_name()
+      raise "this method must be implemented by decendants"
+    end
+
+    ##
+    # convert all dependencies of a building block to rake task prerequisites (e.g. exe needs lib)
+    #
+    def setup_rake_dependencies(task, multitask = nil)
+      dependencies.reverse_each do |d|
+        begin
+          bb = ALL_BUILDING_BLOCKS[d]
+          raise "Error: tried to add the dependencies of \"#{d}\" to \"#{@name}\" but such a building block could not be found!" unless bb
+          
+          if multitask and bb.pre_step
+            multitask.prerequisites.unshift(bb.get_task_name)
+          else
+            task.prerequisites.unshift(bb.get_task_name)
+          end
+        rescue ExitHelperException
+          raise
+        rescue Exception => e
+          Printer.printError e.message
+          ExitHelper.exit(1)
+        end
+      end
+      
+      task
+    end
+
+    def add_output_dir_dependency(file, taskOfFile, addDirToCleanTask)
+      d = File.dirname(file)
+      directory d
+      taskOfFile.enhance([d])
+      
+      if addDirToCleanTask
+        CLOBBER.include(complete_output_dir)
+        if (@output_dir_abs)
+          CLEAN.include(file)
+        else
+          CLEAN.include(complete_output_dir)
+        end
+      end
+    end
+
+    def process_result(cmd, console_output, error_parser, alternate)
+
+      hasError = ($?.success? == false)
+ 
+      if hasError or RakeFileUtils.verbose or (alternate.nil? and not Rake::application.options.silent)
+        exedIn = ""
+        exedIn = " (executed in '#{@project_dir}')" if (hasError or RakeFileUtils.verbose)
+        if cmd.is_a?(Array)
+          puts cmd.join(' ') + exedIn
+        else
+          puts cmd + exedIn
+        end
+      else
+        puts alternate unless Rake::application.options.silent
+      end
+
+      errorPrinted = process_console_output(console_output, error_parser)
+      
+      if hasError
+        if not errorPrinted
+          Printer.printError "Error: system command failed" 
+          res = ErrorDesc.new
+          res.file_name = @project_dir
+          res.line_number = 0
+          res.message = "Unknown error, see log output. Maybe the lake error parser has to be updated..."
+          res.severity = ErrorParser::SEVERITY_ERROR
+          Rake.application.idei.set_errors([res])
+        end
+        
+        raise SystemCommandFailed.new
+      end
+    end
 
+    def read_file_or_empty_string(filename)
+      begin
+        return File.read(filename)
+      rescue
+        return ""
+      end
+    end
+
+    def typed_file_task(type, *args, &block)
+      t = file *args do
+        block.call
+      end
+      t.type = type
+      t.progress_count = 1
+      return t
+    end
+
+    def remove_empty_strings_and_join(a, j=' ')
+      return a.reject{|e|e.to_s.empty?}.join(j)
+    end
+
+    def catch_output(cmd)
+      new_command = "#{cmd} 2>&1"
+      # "/" does not work on windows with backticks, switch the separator on windows:
+      new_command.gsub!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+      return `#{new_command}`
+    end
+
+    def check_config_file()
+      if @config_date
+        @config_files.each do |c|
+          err_msg = nil
+          if File.exists?(c) and File.mtime(c) > @config_date
+            @config_date = File.mtime(c)
+            begin
+              FileUtils.touch(c)
+            rescue Exception
+            end
+          end
+        end
+      end
+    end
+
+  end
+  
 end

data/lib/cxxproject/buildingblocks/command_line.rb

@@ -1,30 +1,79 @@
 require 'cxxproject/buildingblocks/building_block'
+require 'cxxproject/utils/process'
 
-class CommandLine < BuildingBlock
+module Cxxproject
 
-  def set_command_line(x)
-    @line = x
-    self
-  end
+  class CommandLine < BuildingBlock
 
-  def get_command_line
-    @line
-  end
+    def set_command_line(x)
+      @line = x
+      self
+    end
 
-  def get_target
-    @target
-  end
+    def get_command_line
+      @line
+    end
 
-  @@command_line_num = 0
-  def initialize(name)
-    super(name)
-    @line = name
-    @@command_line_num = @@command_line_num + 1
-    @num = @@command_line_num
-  end
+    def set_defined_in_file(x)
+      @defined_in_file = x
+      self
+    end
 
-  def get_task_name()
-    "command line (#{@num}): " + get_command_line
-  end
+    def get_defined_in_file
+      @defined_in_file
+    end
+    
+    def set_defined_in_line(x)
+      @defined_in_line = x
+      self
+    end
 
+    def get_defined_in_line
+      @defined_in_line
+    end    
+
+    def initialize(name)
+      set_command_line(name)
+      @num = Rake.application.command_line_number
+      super(get_task_name)
+    end
+
+    def get_task_name()
+      "command line (#{@num}): " + get_command_line
+    end
+
+    def convert_to_rake()
+      res = task get_task_name do
+        Dir.chdir(@project_dir) do      
+          check_config_file      
+          cmd = get_command_line
+          puts cmd + (RakeFileUtils.verbose ? " (executed in '#{@project_dir}')" : "")
+          cmd_result = false
+          begin
+            cmd_result = ProcessHelper.spawnProcess(cmd + " 2>&1")
+          rescue
+          end
+          if (cmd_result == false)
+            if Rake.application.idei
+              err_res = ErrorDesc.new
+              err_res.file_name = (@defined_in_file ? @defined_in_file : @project_dir)
+              err_res.line_number = (@defined_in_line ? @defined_in_line : 0)
+              err_res.severity = ErrorParser::SEVERITY_ERROR
+              err_res.message = "Command \"#{get_command_line}\" failed"
+              Rake.application.idei.set_errors([err_res])
+            end
+            Printer.printError "Error: command \"#{get_command_line}\" failed" + (RakeFileUtils.verbose ? "" : " (executed in '#{@project_dir}')")
+            raise SystemCommandFailed.new
+          end          
+        end
+      end
+      res.immediate_output = true
+      res.transparent_timestamp = true
+      res.type = Rake::Task::COMMANDLINE
+      setup_rake_dependencies(res)
+      res
+    end
+    
+
+  end
 end

data/lib/cxxproject/buildingblocks/custom_building_block.rb

@@ -1,17 +1,41 @@
 require 'cxxproject/buildingblocks/building_block'
 
 # todo...
+module Cxxproject
 
-class CustomBuildingBlock < BuildingBlock
-  attr_reader :custom_command
+  class CustomBuildingBlock < BuildingBlock
+    attr_reader :custom_command, :actions
 
-  def set_custom_command(c)
-    @custom_command = c
-    self
-  end
+    def set_custom_command(c)
+      @custom_command = c
+      self
+    end
 
-  def get_task_name()
-    raise "todo"
-  end
+    def get_task_name()
+      name
+    end
+
+    def set_actions(actions)
+      if actions.kind_of?(Array)
+        @actions = actions
+      else
+        @actions = [actions]
+      end
+    end
+
+    def convert_to_rake()
+      desc get_task_name
+      res = task get_task_name do
+        actions.each do |a|
+          a.call
+        end
+      end
+      res.type = Rake::Task::CUSTOM
+      setup_rake_dependencies(res)
+      res
+    end
 
+
+
+  end
 end