cxxproject 0.2 → 0.4.6

data/lib/cxxproject/utils/ubigraph.rb

@@ -0,0 +1,237 @@
+begin
+
+  require 'rubigraph'
+
+  def apply?(name)
+    name.match(/.*\.apply\Z/) != nil
+  end
+
+
+  module Rubigraph
+    class Vertex
+      alias_method :initialize_original, :initialize
+      def initialize(id = nil)
+        if id != nil
+          @id = id
+        else
+          initialize_original
+        end
+      end
+    end
+  end
+
+  class IdsAndEdges
+    attr_reader :ids, :edges
+    def initialize
+      @ids = Hash.new
+      @edges = Hash.new
+    end
+  end
+
+  class V
+
+    def self.shutdown
+      File.open('id_cache', 'w') do |f|
+        f.write(@@ids_and_edges.to_yaml)
+      end
+    end
+
+    def self.reset
+      begin
+        File.delete('id_cache')
+      rescue StandardError => e
+        puts e
+        puts 'problem deleting id_cache'
+      end
+      @@ids_and_edges = IdsAndEdges.new
+    end
+
+    def self.startup
+      begin
+        @@ids_and_edges = YAML.load_file('id_cache')
+      rescue
+        @@ids_and_edges = IdsAndEdges.new
+      end
+    end
+
+    attr_reader :v
+
+    def initialize(name)
+      h = @@ids_and_edges.ids
+      id = h[name]
+      if !id
+        @v = Rubigraph::Vertex.new
+        @@ids_and_edges.ids()[name] = @v.id
+      else
+        @v = Rubigraph::Vertex.new(id)
+      end
+    end
+    def self.create_edge(edge_and_task1, edge_and_task2)
+      complete_name = "#{edge_and_task1[:task].name}->#{edge_and_task2[:task].name}"
+      if @@ids_and_edges.edges.has_key?(complete_name)
+        return nil
+      else
+        e = Rubigraph::Edge.new(edge_and_task1[:vertex].v, edge_and_task2[:vertex].v)
+        @@ids_and_edges.edges[complete_name] = true
+        return e
+      end
+    end
+  end
+
+  class UbiGraphSupport
+
+    def object?(name)
+      name.match(/.*\.o\Z/) != nil
+    end
+
+    def exe?(name)
+      name.match(/.*\.exe\Z/) != nil
+    end
+    def library?(name)
+      name.match(/.*\.a\Z/) != nil
+    end
+    def multitask?(name)
+      name.index("Sources") == 0
+    end
+    def interesting?(name)
+      exe?(name) || object?(name) || library?(name) || multitask?(name)
+    end
+
+    def initialize
+      Rake::Task.tasks.each do |t|
+        if apply?(t.name)
+          t.invoke
+        end
+      end
+
+      interesting_tasks = Rake::Task.tasks.select { |i| interesting?(i.name) }
+      @vertices = {}
+
+      # create vertices
+      interesting_tasks.each do |task|
+        v = V.new(task.name)
+        @vertices[task.name] = {:vertex=>v, :task=>task}
+      end
+
+      # create edges
+      interesting_tasks.each do |task|
+        name = task.name
+        v1 = @vertices[name]
+        task.prerequisites.each do |p|
+          v2 = @vertices[p]
+          if (v2 != nil)
+            e = V.create_edge(v1, v2)
+            e.width=2 if e
+          end
+        end
+      end
+
+      @vertices.each do |k, value|
+        v = value[:vertex]
+        v.v.label = k
+        set_attributes(v, k)
+      end
+
+    end
+
+    def update_colors
+      @vertices.each_key do |k|
+        set_attributes(v, k)
+      end
+    end
+
+    def set_attributes(v, name)
+      v.v.color = state2color(name)
+      v.v.shape = name2shape(name)
+      v.v.size = name2size(name)
+    end
+
+    def name2shape(name)
+      if object?(name)
+        return 'cube'
+      elsif exe?(name)
+        return 'sphere'
+      elsif multitask?(name)
+        return 'torus'
+      else
+        return 'octahedron'
+      end
+    end
+    def name2size(name)
+      if object?(name)
+        return 0.7
+      elsif exe?(name)
+        return 1.2
+      else
+        return 1.0
+      end
+    end
+    def state2color(name)
+      t = @vertices[name][:task]
+      begin
+        if t.dirty?
+          return '#ff0000'
+        else
+          return '#00ff00'
+        end
+      rescue StandardError => bang
+        puts bang
+        return '#ff00ff'
+      end
+    end
+
+    def update(name, color)
+      @vertices[name][:vertex].v.color = color if @vertices[name]
+    end
+
+    YELLOW = '#ffff00'
+    def before_prerequisites(name)
+      update(name, YELLOW)
+    end
+
+    ORANGE = '#ff7f00'
+    def after_prerequisites(name)
+      update(name, ORANGE)
+    end
+
+    BLUE = '#0000ff'
+    def before_execute(name)
+      update(name, BLUE)
+    end
+
+    GREEN = '#00ff00'
+    def after_execute(name)
+      update(name, GREEN)
+    end
+  end
+
+  namespace :rubygraph do
+    task :init do
+      Rubigraph.init
+      V.startup
+      at_exit do
+        V.shutdown
+      end
+    end
+
+    desc 'clear rubygraph'
+    task :clear => :init do
+      Rubigraph.clear
+      V.reset
+    end
+
+    desc 'update rubygraph'
+    task :update => :init do
+      begin
+        require 'cxxproject/extensions/rake_listener_ext'
+        require 'cxxproject/extensions/rake_dirty_ext'
+        Rake::add_listener(UbiGraphSupport.new)
+      rescue StandardError => e
+        puts e
+      end
+    end
+  end
+
+rescue Exception => e
+  puts e
+end

data/lib/cxxproject/{utils.rb → utils/utils.rb}

@@ -1,15 +1,33 @@
-
+# Simple helper query the operating system we are running in
 module OS
+
+  # Is it windows
   def OS.windows?
     (RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/) != nil
   end
+
+  # Is it osx
   def OS.mac?
     (RUBY_PLATFORM =~ /darwin/) != nil
   end
+
+  # Is it kind of unix
   def OS.unix?
     !OS.windows?
   end
+
+  # Is it linux
   def OS.linux?
     OS.unix? and not OS.mac?
   end
+
 end
+
+module Utils
+
+def self.deep_copy(x)
+  Marshal.load(Marshal.dump(x))
+end
+
+
+end

data/lib/cxxproject.rb

@@ -1,227 +1,17 @@
+# Just the default file wich is auto-required in the gem and which requires all needed stuff
+require 'rubygems'
+require 'yaml'
 require 'rake/clean'
-require 'cxxproject/utils'
-require 'cxxproject/dependencies'
-require 'cxxproject/compiler'
-require 'cxxproject/gcccompiler'
-require 'cxxproject/osxcompiler'
 
-module OS
-  def OS.windows?
-    (RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/) != nil
-  end
-  def OS.mac?
-    (RUBY_PLATFORM =~ /darwin/) != nil
-  end
-  def OS.unix?
-    !OS.windows?
-  end
-  def OS.linux?
-    OS.unix? and not OS.mac?
-  end
-end
+require 'cxxproject/extensions/string_ext'
+require 'cxxproject/task_maker'
+require 'cxxproject/utils/utils'
+require 'cxxproject/torake'
+require 'cxxproject/task_maker'
+require 'cxxproject/torake/compiler'
+require 'cxxproject/torake/gcccompiler'
+require 'cxxproject/torake/osxcompiler'
+require 'cxxproject/utils/ubigraph'
 
-ALL_BUILDING_BLOCKS = {}
+include Cxxproject::Toolchain
 
-ALL = FileList.new
-
-class BuildingBlock
-  attr_accessor :name, :base, :dependencies
-  def initialize(name)
-    @name = name
-    @dependencies = []
-    ALL_BUILDING_BLOCKS[@name] = self
-  end
-  def to_s
-    inspect
-  end
-end
-
-class LibraryBuildingBlock < BuildingBlock
-  attr_accessor :includes
-  def initialize(name)
-    super
-    @includes = ['.']
-  end
-end
-
-class SourceBuildingBlock < LibraryBuildingBlock
-  attr_accessor :sources
-
-  def initialize(name)
-    super(name)
-    @sources = []
-    @dependencies = []
-  end
-end
-
-class SourceLibrary < SourceBuildingBlock
-  attr_accessor :defines
-  def initialize(name)
-    super(name)
-    @defines = []
-  end
-end
-
-class Exe < SourceBuildingBlock
-  def initialize(name)
-    super(name)
-  end
-end
-
-class BinaryLibrary < LibraryBuildingBlock
-  def initialize(name)
-    super
-    @includes = ['']
-  end
-end
-
-class OsxCompiler
-  def initialize(output_path)
-    @output_path = output_path
-  end
-
-  def register(name)
-    CLEAN.include(name)
-    ALL.include(name)
-  end
-
-  def transitive_includes(lib)
-    res = Dependencies.transitive_dependencies([lib.name]).map do |i|
-      if (i.instance_of?(BinaryLibrary))
-        i.includes
-      else
-        i.includes.map { |include| File.join(i.base, include) }
-      end
-    end
-    return res.flatten.delete_if{|i|i.size == 0}
-  end
-
-  def transitive_libs(from)
-    res = Dependencies.transitive_dependencies([from.name]).delete_if{|i|i.instance_of?(Exe)}.map do |i|
-      if (i.instance_of?(BinaryLibrary))
-        "-L/opt/local/lib -l#{i.name}"
-      else
-        "osx/lib#{i.name}.a"
-      end
-    end
-    return res
-  end
-
-  def create_object_file(lib, relative_source)
-    source = File.join(lib.base, relative_source)
-    out = File.join(@output_path, "#{source}.o")
-    outputdir = File.dirname(out)
-    directory outputdir
-    register(out)
-    desc "compiling #{source}"
-    res = file out => [source, outputdir] do |t|
-      includes = transitive_includes(lib)
-      include_string = includes.inject('') { | res, i | "#{res} -I#{i} " }
-      sh "g++ -c #{source} #{include_string} -o #{t.name}"
-    end
-    return res
-  end
-
-  def static_lib_path(name)
-    libname = "lib#{name}.a"
-    fullpath = File.join(@output_path, libname)
-    return fullpath
-  end
-
-  def create_source_lib(lib, objects)
-    fullpath = static_lib_path(lib.name)
-    command = objects.inject("ar -r #{fullpath}") do |command, o|
-      "#{command} #{o}"
-    end
-    register(fullpath)
-    deps = objects.dup
-    deps += lib.dependencies.map {|dep|get_path_for_lib(dep)}
-    desc "link lib #{lib.name}"
-    res = file fullpath => deps do
-      sh command
-    end
-    return res
-  end
-
-  def get_path_for_lib(l)
-    lib = ALL_BUILDING_BLOCKS[l]
-    if !lib
-      raise "could not find buildingblock with name '#{l}'"
-    end
-    if (lib.instance_of?(BinaryLibrary))
-      "/opt/local/lib/lib#{lib.name}.a"
-    else
-      static_lib_path(lib.name)
-    end
-  end
-
-  def create_exe(exe, objects)
-    exename = "#{exe.name}.exe"
-    fullpath = File.join(@output_path, exename)
-    command = objects.inject("g++ -all_load -o #{fullpath}") do |command, o|
-      "#{command} #{o}"
-    end
-
-    dep_paths = exe.dependencies.map {|dep|get_path_for_lib(dep)}
-    register(fullpath)
-    deps = objects.dup
-    deps += dep_paths
-    desc "link exe #{exe.name}"
-    res = file fullpath => deps do
-      sh transitive_libs(exe).inject(command) {|command,l|"#{command} #{l}"}
-    end
-    return res
-  end
-end
-
-
-def build_source_lib(lib)
-  objects = lib.sources.map do |s|
-    Compiler.create_object_file(lib, File.basename(s))
-  end
-  Compiler.create_source_lib(lib, objects)
-end
-
-def build_exe(exe)
-  objects = exe.sources.map do |s|
-    Compiler.create_object_file(exe, File.basename(s))
-  end
-  Compiler.create_exe(exe, objects)
-end
-
-class CxxProject2Rake
-
-  def initialize(projects)
-    register_projects(projects)
-    convert_to_rake
-  end
-
-  def register_projects(projects)
-    projects.each do |project_file|
-      loadContext = Class.new
-      loadContext.module_eval(File.read(project_file))
-      c = loadContext.new
-      raise "no 'define_project' defined in project.rb" unless c.respond_to?(:define_project)
-      cd File.dirname(project_file) do | base_dir |
-        project = c.define_project
-        ALL_BUILDING_BLOCKS[project.name] = project
-        project.base = base_dir
-        project.to_s
-      end
-    end
-  end
-  def convert_to_rake
-    ALL_BUILDING_BLOCKS.values.each do |building_block|
-      if (building_block.instance_of?(SourceLibrary)) then
-        build_source_lib(building_block)
-      elsif (building_block.instance_of?(Exe)) then
-        build_exe(building_block)
-      elsif (building_block.instance_of?(BinaryLibrary)) then
-      else
-        raise 'unknown building_block'
-      end
-    end
-    task :default => ALL.to_a do
-    end
-  end
-end

data/lib/tools/Rakefile.rb.template

@@ -0,0 +1,10 @@
+require 'cxxproject'
+BuildDir = "BuildDir"
+
+unittest_flags = {
+  :DEFINES => ['UNIT_TEST','CPPUNIT_MAIN=main'],
+  :FLAGS => "-O0 -g3 -Wall"
+}
+toolchain = Provider.modify_cpp_compiler("GCC", unittest_flags)
+dependent_projects =  ['./project.rb']
+CxxProject2Rake.new(dependent_projects, BuildDir, toolchain, './')

data/lib/tools/project.rb.template

@@ -0,0 +1,6 @@
+cxx_configuration do
+  <%= building_block %> "<%= name %>",
+    :sources => FileList['**/*.cpp'],
+    :includes => ['include'],
+    :dependencies => []
+end

data/lib/tools/projectWizard.rb

@@ -0,0 +1,44 @@
+require 'rake'
+require 'erb'
+
+def prepare_project(d)
+  require 'highline/import'
+  if agree("This will create a new cxx-project config in dir \"#{d}\" \nAre you sure you want to continue? [yn] ")
+    bb = nil 
+    choose do |menu|
+      menu.prompt = "what building block do you want to start with?"
+
+      menu.choice(:exe) { bb = "exe" }
+      menu.choices(:lib) { bb = "source_lib" }
+    end
+
+    create_project(d, bb)
+  else
+    say "stopped project creation"
+  end
+end
+
+def create_project(d, bb)
+  rakefile_template = File.join(File.dirname(__FILE__),"..","tools","Rakefile.rb.template")
+  projectrb_template = File.join(File.dirname(__FILE__),"..","tools","project.rb.template")
+  s1 = IO.read(rakefile_template)
+  s2 = IO.read(projectrb_template)
+  name = "testme"
+  building_block = bb
+  template1 = ERB.new s1
+  template2 = ERB.new s2
+  mkdir_p(d, :verbose => false)
+  cd(d,:verbose => false) do
+    if ((File.exists? "Rakefile.rb") || (File.exists? "project.rb"))
+      abort "cannot create project in this directory, existing files would be overwritten!"
+    end
+    File.open("Rakefile.rb", 'w') do |f|
+      f.write template1.result(binding)
+    end
+    File.open("project.rb", 'w') do |f|
+      f.write template2.result(binding)
+    end
+  end
+end
+
+