cxxproject 0.2

data/Rakefile.rb

@@ -0,0 +1,47 @@
+require 'rake/gempackagetask'
+require 'roodi'
+require 'roodi_task'
+require 'spec/rake/spectask'
+
+desc "Default Task"
+task :default => [:package, :roodi]
+
+PKG_VERSION = '0.2'
+PKG_FILES = FileList[
+    'lib/**/*.rb',
+    'Rakefile.rb',
+    'spec/**/*.rb'
+#    'doc/**/*'
+  ]
+
+spec = Gem::Specification.new do |s|
+  s.name = 'cxxproject'
+  s.version = PKG_VERSION
+  s.summary = "Cpp Support for Rake."
+  s.description = <<-EOF
+    Some more high level building blocks for cpp projects.
+  EOF
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+  s.author = ''
+  s.email = ''
+  s.homepage = ''
+end
+
+RoodiTask.new
+Rake::GemPackageTask.new(spec) {|pkg|}
+
+task :gem => [:spec, :roodi]
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new() do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+end
+
+task :default => [:install]
+
+desc "install gem globally"
+task :install => :gem do
+  sh "gem install pkg/#{spec.name}-#{spec.version}.gem"
+end
+

data/lib/cxxproject/compiler.rb

@@ -0,0 +1,80 @@
+class Compiler
+  def initialize(output_path)
+    @output_path = output_path
+  end
+
+  def include(name)
+    CLEAN.include(name)
+#    ALL.include(name)
+  end
+
+  def transitive_includes(lib)
+    res = Dependencies.transitive_dependencies([lib.name]).map do |i|
+      i.includes.map { |include| File.join(i.base, include) }
+    end
+    return res.flatten
+  end
+  def transitive_libs(from)
+    res = Dependencies.transitive_dependencies([from.name]).delete_if{|i|i.instance_of?(Exe)}.map do |i|
+      "#{@output_path}/lib#{i.name}.a"
+    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
+    include(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
+    include(fullpath)
+    deps = objects.dup
+    deps += lib.dependencies.map {|dep|static_lib_path(dep)}
+    desc "link lib #{lib.name}"
+    res = file fullpath => deps do
+      sh command
+    end
+    return res
+  end
+
+  def create_exe(exe, objects)
+    exename = "#{exe.name}.exe"
+    fullpath = File.join(@output_path, exename)
+    command = objects.inject("g++ -o #{fullpath}") do |command, o|
+      "#{command} #{o}"
+    end
+
+    dep_paths = exe.dependencies.map {|dep|static_lib_path(dep)}
+    include(fullpath)
+    deps = objects.dup
+    deps += dep_paths
+    desc "link exe #{exe.name}"
+    res = file fullpath => deps do
+      libs = transitive_libs(exe)
+      command = libs.inject(command) { |command, l| "#{command} #{l}" }
+      sh command
+    end
+    return res
+  end
+end
+

data/lib/cxxproject/dependencies.rb

@@ -0,0 +1,41 @@
+class Dependencies
+
+  attr_reader :all_libs
+
+  def initialize(lib_strings)
+    @all_libs = []
+    lib_strings.each do |lib_string|
+      add(lib_string)
+    end
+  end
+
+  def self.transitive_dependencies(lib)
+    return Dependencies.new(lib).all_libs
+  end
+
+
+
+  def self.tr_libs(libs)
+    return LibHelper.new(libs).all_libs
+  end
+
+  def add_unique(lib)
+    @all_libs.delete(lib)
+    @all_libs.push(lib)
+  end
+
+  def add(lib)
+    bb = ALL_BUILDING_BLOCKS[lib]
+    if !bb
+      raise "dependency not found #{lib}"
+    end
+    add_unique(bb)
+    bb.dependencies.each do |dep|
+      add(dep)
+    end
+  end
+
+
+
+
+end

data/lib/cxxproject/gcccompiler.rb

@@ -0,0 +1,7 @@
+
+class GccCompiler < Compiler
+  def initialize(output_path)
+    super(output_path)
+  end
+end
+

data/lib/cxxproject/osxcompiler.rb

@@ -0,0 +1,7 @@
+
+class OsxCompiler < Compiler
+  def initialize(output_path)
+    super(output_path)
+  end
+end
+

data/lib/cxxproject/utils.rb

@@ -0,0 +1,15 @@
+
+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

data/lib/cxxproject.rb

@@ -0,0 +1,227 @@
+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
+
+ALL_BUILDING_BLOCKS = {}
+
+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/spec/dependencies_spec.rb

@@ -0,0 +1,19 @@
+require 'cxxproject'
+
+describe Dependencies do
+  it 'should build the right dependency-chain' do
+    lib1 = SourceLibrary.new('1')
+    lib2 = SourceLibrary.new('2')
+    lib2.dependencies = ['1']
+    lib3 = SourceLibrary.new('3')
+    lib3.dependencies = ['1']
+    lib4 = SourceLibrary.new('4')
+    lib4.dependencies = ['2', '3']
+    deps = Dependencies.transitive_dependencies(['4'])
+    deps.map {|d|d.name}.should == ['4', '2', '3', '1']
+  end
+  it 'should create .d files' do
+    pending
+    1.should == 0
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: cxxproject
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  version: "0.2"
+platform: ruby
+authors: 
+- ""
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-09 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: "    Some more high level building blocks for cpp projects.\n"
+email: ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/cxxproject/compiler.rb
+- lib/cxxproject/dependencies.rb
+- lib/cxxproject/gcccompiler.rb
+- lib/cxxproject/osxcompiler.rb
+- lib/cxxproject/utils.rb
+- lib/cxxproject.rb
+- Rakefile.rb
+- spec/dependencies_spec.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Cpp Support for Rake.
+test_files: []
+