cxx 0.1.5

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/Rakefile.rb

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+task :package => :build

data/bin/cxx

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'cxx/wizard/project_wizard'
+
+if ARGV.size < 1
+	puts "usage: cxx project-dir"
+	exit 0
+end
+prepare_project(ARGV[0])

data/cxx.gemspec

@@ -0,0 +1,18 @@
+spec = Gem::Specification.new do |s|
+  s.name = 'cxx'
+  s.description = 'ruby-based dsl for cxxproject'
+  s.summary = 'defines the method cxx_configuration'
+  s.version = '0.1.5'
+  s.author = 'christian koestlin'
+  s.email = 'christian.koestlin@gmail.com'
+  s.platform = Gem::Platform::RUBY
+  s.files = `git ls-files`.split($\)
+  s.require_path = 'lib'
+
+  s.add_dependency 'cxxproject'
+  s.add_dependency 'highline'
+
+  s.executables = ['cxx']
+
+  s.has_rdoc = false
+end

data/lib/cxx.rb

@@ -0,0 +1,223 @@
+require 'rubygems'
+
+require 'cxxproject/cxxproject'
+require 'logger'
+require 'pp'
+require 'pathname'
+require 'cxxproject/ext/rake'
+require 'cxxproject/buildingblocks/module'
+require 'cxxproject/buildingblocks/makefile'
+require 'cxxproject/buildingblocks/executable'
+require 'cxxproject/buildingblocks/source_library'
+require 'cxxproject/buildingblocks/single_source'
+require 'cxxproject/buildingblocks/binary_library'
+require 'cxxproject/buildingblocks/custom_building_block'
+require 'cxxproject/buildingblocks/command_line'
+require 'cxxproject/toolchain/colorizing_formatter'
+require 'cxxproject/plugin_context'
+require 'cxx/eval_context'
+
+module Cxx
+
+  class RubyDsl
+    attr_accessor :base_dir, :all_tasks, :build_dir
+
+    def initialize(projects, build_dir, toolchain_name, base_dir='.', &option_block)
+      @build_dir = build_dir
+      option_block.call if option_block
+      toolchain = Cxxproject::Toolchain::Provider[toolchain_name]
+      raise "no provider with name \"#{toolchain_name}\" found" unless toolchain
+      @base_dir = base_dir
+      cd(@base_dir, :verbose => false) do
+        @projects = projects.to_a
+      end
+
+      # TODO: this should be cleaned up somehow...
+      if Cxxproject::Utils::OS.linux?
+        toolchain[:LINKER][:LIB_PREFIX_FLAGS] = "-Wl,--whole-archive"
+        toolchain[:LINKER][:LIB_POSTFIX_FLAGS] = "-Wl,--no-whole-archive"
+      end
+
+      Rake::application.deriveIncludes = true
+
+      initialize_logging(build_dir)
+      @all_tasks = instantiate_tasks(toolchain, build_dir)
+
+      create_generic_tasks
+      create_console_colorization
+      create_multitask
+      create_dont_bail_on_first_task
+      describe_clean_task
+
+      load_nontoolchain_plugins
+    end
+
+    def load_nontoolchain_plugins
+      registry = Frazzle::Registry.new('cxxproject', '_', '-')
+      registry.get_all_plugins.select { |name|name.index('toolchain') == nil }.each do |plugin|
+        registry.load_plugin(plugin, Cxxproject::PluginContext.new(self, Cxxproject::ALL_BUILDING_BLOCKS, @log))
+      end
+    end
+
+    def initialize_logging(build_dir)
+      @log = Logger.new(STDOUT)
+      @log.formatter = proc { |severity, datetime, progname, msg|
+        "#{severity}: #{msg}\n"
+      }
+      # Logger loglevels: fatal, error, warn, info, debug
+      # Rake --verbose -> info
+      # Rake --trace -> debug
+      @log.level = Logger::ERROR
+      @log.level = Logger::INFO if RakeFileUtils.verbose == true
+      @log.level = Logger::DEBUG if Rake::application.options.trace
+      @log.debug "initializing for build_dir: \"#{build_dir}\", base_dir: \"#{@base_dir}\""
+    end
+
+    def describe_clean_task
+      Rake::Task[:clean].add_description('clean')
+    end
+
+    def create_dont_bail_on_first_task
+      desc 'dont bail on first error'
+      task :dont_bail_on_first_error do
+        Rake::Task.bail_on_first_error = false
+      end
+    end
+
+    def create_multitask
+      desc 'set parallelization of multitask'
+      task :multitask, :threads do |t, args|
+        arg = args.threads
+        if arg
+          Rake::application.max_parallel_tasks = arg.to_i
+        end
+      end
+    end
+
+    def create_console_colorization
+      # default is on
+      Cxxproject::ColorizingFormatter.enabled = true
+      desc 'Toggle colorization of console output (use true|t|yes|y|1|on for true ... everything else is false)'
+      task :toggle_colorize, :on_off do |t, args|
+        arg = args[:on_off] || 'false'
+        on_off = arg.match(/(true|t|yes|y|1|on)$/) != nil
+        Cxxproject::ColorizingFormatter.enabled = on_off
+      end
+    end
+
+    def create_generic_tasks
+      tasks = [:lib, :exe, :run]
+      tasks << nil
+      tasks.each { |i| create_filter_task_with_namespace(i) }
+    end
+
+    def create_filter_task_with_namespace(basename)
+      if basename
+        desc "invoke #{basename} with filter"
+        namespace basename do
+          create_filter_task("#{basename}:")
+        end
+      else
+        desc 'invoke with filter'
+        create_filter_task('')
+      end
+    end
+
+    def create_filter_task(basename)
+      task :filter, :filter do |t, args|
+        filter = ".*"
+        if args[:filter]
+          filter = "#{args[:filter]}"
+        end
+        filter = Regexp.new("#{basename}#{filter}")
+        Rake::Task.tasks.each do |to_check|
+          name = to_check.name
+          if ("#{basename}:filter" != name)
+            match = filter.match(name)
+            if match
+              to_check.invoke
+            end
+          end
+        end
+      end
+    end
+
+    def instantiate_tasks(toolchain, build_dir)
+      check_for_project_configs
+
+      if @log.debug?
+        @log.debug "project_configs:"
+        @projects.each { |c| @log.debug " *  #{c}" }
+      end
+      register_projects()
+      Cxxproject::ALL_BUILDING_BLOCKS.values.each do |block|
+        prepare_block(block, toolchain, build_dir)
+      end
+      Cxxproject::ALL_BUILDING_BLOCKS.values.inject([]) do |memo,block|
+        @log.debug "creating tasks for block: #{block.name}/taskname: #{block.get_task_name} (#{block})"
+        memo << block.convert_to_rake()
+      end
+    end
+
+    def check_for_project_configs
+      cd(@base_dir, :verbose => false) do
+        @projects.each do |p|
+          abort "project config #{p} cannot be found!" unless File.exists?(p)
+        end
+      end
+    end
+
+    def prepare_block(block, toolchain, build_dir)
+      block.set_tcs(toolchain) unless block.has_tcs?
+      block.set_output_dir(Dir.pwd + "/" + build_dir)
+      block.complete_init()
+    end
+
+    def register_projects()
+      cd(@base_dir,:verbose => false) do |b|
+        @projects.each_with_index do |project_file, i|
+          @log.debug "register project #{project_file}"
+          dirname = File.dirname(project_file)
+          @log.debug "dirname for project was: #{dirname}"
+          cd(dirname,:verbose => false) do | base_dir |
+            @log.debug "register project #{project_file} from within directory: #{Dir.pwd}"
+            eval_file(b, File.basename(project_file))
+          end
+        end
+      end
+    end
+
+    def eval_file(b, project_file)
+      loadContext = EvalContext.new
+      begin
+        loadContext.eval_project(File.read(File.basename(project_file)), project_file, Dir.pwd)
+      rescue Exception => e
+        puts "problems with #{File.join(b, project_file)} in dir: #{Dir.pwd}"
+        raise e
+      end
+
+      loadContext.all_blocks.each do |block|
+        block.
+          set_project_dir(Dir.pwd).
+          set_config_files([Dir.pwd + "/" + project_file])
+        if block.respond_to?(:sources) && block.sources.instance_of?(Rake::FileList)
+          block.set_sources(block.sources.to_a)
+        end
+      end
+    end
+
+    def define_project_info_task
+      desc "shows your defined projects"
+      task :project_info do
+        Cxxproject::ALL_BUILDING_BLOCKS.each_value do |bb|
+          pp bb
+        end
+      end
+    end
+
+  end
+end
+
+def cxx(projects, output_dir, toolchain_name, base_dir, &block)
+  Cxx::RubyDsl.new(projects, output_dir, toolchain_name, base_dir, &block)
+end

data/lib/cxx/eval_context.rb

@@ -0,0 +1,126 @@
+require 'cxxproject/context'
+require 'cxxproject/cxxproject'
+require 'cxxproject/utils/utils'
+
+module Cxx
+  class BinaryLibs
+    class << self
+      def [](*libs)
+        libraries = Array.new
+        libs.each do |x|
+          libraries << Cxxproject::BinaryLibrary.new(x)
+        end
+        libraries
+      end
+    end
+  end
+
+  class EvalContext
+    include Cxxproject::Context
+
+    attr_accessor :all_blocks
+
+    # must be called to add building blocks
+    def cxx_configuration(&block)
+      @all_blocks = []
+      block.call
+    end
+
+    def eval_project(project_text, project_file, pwd)
+      @current_project_file = project_file
+      @current_working_dir = pwd
+      instance_eval(project_text)
+    end
+
+    # specify an executable
+    # hash supports:
+    # * :sources
+    # * :includes
+    # * :dependencies
+    # * :libpath
+    # * :output_dir
+    def exe(name, hash)
+      raise "not a hash" unless hash.is_a?(Hash)
+      check_hash(hash,[:sources,:includes,:dependencies,:libpath,:output_dir])
+      bblock = Cxxproject::Executable.new(name)
+      bblock.set_sources(hash[:sources]) if hash.has_key?(:sources)
+      bblock.set_includes(get_as_array(hash, :includes)) if hash.has_key?(:includes)
+      calc_lib_searchpath(hash).each { |sp| bblock.add_lib_element(Cxxproject::HasLibraries::SEARCH_PATH, sp) }
+      if hash.has_key?(:dependencies)
+        bblock.set_dependencies(hash[:dependencies])
+        hash[:dependencies].each { |d| bblock.add_lib_element(Cxxproject::HasLibraries::DEPENDENCY, d) }
+      end
+      bblock.set_output_dir(hash[:output_dir]) if hash.has_key?(:output_dir)
+      all_blocks << bblock
+    end
+
+    def calc_lib_searchpath(hash)
+      if hash.has_key?(:libpath)
+        hash[:libpath]
+      else
+        if Cxxproject::Utils::OS.linux? || Cxxproject::Utils::OS.mac?
+          ["/usr/local/lib","/usr/lib"]
+        elsif Cxxproject::Utils::OS.windows?
+          ["C:/tool/cygwin/lib", "C:/Tool/cygwin/usr/local/lib"]
+        end
+      end
+    end
+
+    # specify a sourcelib
+    # hash supports:
+    # * :sources
+    # * :includes
+    # * :dependencies
+    # * :toolchain
+    # * :file_dependencies
+    # * :output_dir
+    def source_lib(name, hash)
+      raise "not a hash" unless hash.is_a?(Hash)
+      check_hash(hash,[:sources, :includes, :dependencies, :toolchain, :file_dependencies, :output_dir])
+      raise ":sources need to be defined" unless hash.has_key?(:sources)
+      bblock = Cxxproject::SourceLibrary.new(name)
+      bblock.set_sources(hash[:sources])
+      bblock.set_includes(get_as_array(hash, :includes)) if hash.has_key?(:includes)
+      bblock.set_tcs(hash[:toolchain]) if hash.has_key?(:toolchain)
+      if hash.has_key?(:dependencies)
+        bblock.set_dependencies(hash[:dependencies])
+        hash[:dependencies].each { |d| bblock.add_lib_element(Cxxproject::HasLibraries::DEPENDENCY, d) }
+      end
+      bblock.file_dependencies = hash[:file_dependencies] if hash.has_key?(:file_dependencies)
+      bblock.set_output_dir(hash[:output_dir]) if hash.has_key?(:output_dir)
+      all_blocks << bblock
+    end
+
+    # specify some binary libs
+    # returns all binary libs as array
+    def bin_libs(*names)
+      res = []
+      mapped = names.map{|n|n.to_s}
+      mapped.each do |name|
+        res << Cxxproject::BinaryLibrary.new(name)
+      end
+      mapped
+    end
+
+    def compile(name, hash)
+      raise "not a hash" unless hash.is_a?(Hash)
+      check_hash(hash,[:sources,:includes])
+      bblock = Cxxproject::SingleSource.new(name)
+      bblock.set_sources(hash[:sources]) if hash.has_key?(:sources)
+      bblock.set_includes(hash[:includes]) if hash.has_key?(:includes)
+      all_blocks << bblock
+    end
+
+    def custom(name, hash)
+      raise "not a hash" unless hash.is_a?(Hash)
+      check_hash(hash,[:execute, :dependencies])
+      bblock = Cxxproject::CustomBuildingBlock.new(name)
+      bblock.set_actions(hash[:execute]) if hash.has_key?(:execute)
+      if hash.has_key?(:dependencies)
+        bblock.set_dependencies(hash[:dependencies])
+      end
+      all_blocks << bblock
+    end
+
+  end
+end

data/lib/cxx/wizard/Rakefile.rb.template

@@ -0,0 +1,11 @@
+require 'cxx'
+
+unittest_flags = {
+  :DEFINES => ['UNIT_TEST','CPPUNIT_MAIN=main'],
+  :FLAGS => "-O0 -g3 -Wall"
+}
+
+cxx(Dir['**/project.rb'], 'out', "<%= toolchain %>", './') do
+  Provider.modify_cpp_compiler("<%= toolchain %>", unittest_flags)
+end
+

data/lib/cxx/wizard/project.rb.template

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

data/lib/cxx/wizard/project_wizard.rb

@@ -0,0 +1,113 @@
+require 'rake'
+require 'erb'
+require 'rubygems'
+
+def prepare_project(dir_name)
+  begin
+    require 'highline/import'
+
+    say "This will create a new cxx-project in directory: '#{dir_name}'"
+    if confirm("Are you sure you want to continue") then
+      building_block = choose_building_block
+      generate_makefile = confirm("Do you also whant to generate a rakefile", building_block.eql?("exe"))
+
+      toolchain = nil
+      if generate_makefile then
+        toolchain = choose_toolchain
+        return unless toolchain
+      end
+
+      create_project(dir_name, building_block, toolchain, generate_makefile)
+      say "Completed project-setup ;-)"
+    else
+      say "Stopped project-setup!"
+    end
+
+  rescue Interrupt
+    say "\nStopped project-setup!"
+  rescue LoadError
+    say "Please run 'gem install highline'"
+  end
+end
+
+def choose_building_block
+  res = nil
+  choose do |menu|
+    say "What building-block do you whant to create?"
+    menu.choice(:exe) { res = "exe" }
+    menu.choice(:lib) { res = "source_lib" }
+    menu.prompt = "Select a building-block: "
+  end
+  res
+end
+
+def choose_toolchain
+  res = nil
+  toolchains = []
+  toolchain_pattern = /cxxproject_(.*)toolchain/
+  Gem::Specification.latest_specs.each do |gem|
+    if gem.name =~ toolchain_pattern then
+      toolchains << $1
+    end
+  end
+  if toolchains.length > 0 then
+    choose do |menu|
+      say "What toolchain do you whant to use?"
+      toolchains.each do |toolchain|
+        menu.choice(toolchain.to_sym) { res = toolchain }
+      end
+      menu.prompt = "Select a toolchain: "
+    end
+  else
+    say "No toolchains installed!"
+    candidates = `gem list --remote "cxxproject_.*toolchain"`
+    say "You need at least one toolchain-plugin,- candidates are:\n#{candidates}"
+  end
+  res
+end
+
+def create_project(dir_name, building_block, toolchain, generate_rakefile)
+  rakefile_template = IO.read(File.join(File.dirname(__FILE__),"Rakefile.rb.template"))
+  project_template = IO.read(File.join(File.dirname(__FILE__),"project.rb.template"))
+  binding = create_binding("new-item", building_block, toolchain)
+
+  if !File.directory?(dir_name) then
+    mkdir_p(dir_name, :verbose => false)
+  end
+
+  rakefile_file = "#{dir_name}/Rakefile.rb"
+  if generate_rakefile && (!File.exists?(rakefile_file) || confirm("Override existing '#{rakefile_file}'")) then
+    write_template(rakefile_file, rakefile_template, binding)
+  end
+
+  project_file = "#{dir_name}/project.rb"
+  if !File.exists?(project_file) || confirm("Override existing '#{project_file}'") then
+    write_template(project_file, project_template, binding)
+  end
+end
+
+def create_binding(name, building_block, toolchain)
+  return binding()
+end
+
+def write_template(file_name, template, binding)
+  say "...write: '#{file_name}'"
+  File.open(file_name, 'w') do |f|
+    f.write ERB.new(template).result(binding)
+  end
+end
+
+def confirm(question, default = true)
+  res = nil
+  while res == nil
+    confirm = ask("#{question}? ") { |q| q.default = default ? "Y/n" : "y/N" }
+    if confirm.eql?("Y/n") || confirm.downcase.eql?("yes") || confirm.downcase.eql?("y") then
+      res = true
+    elsif confirm.eql?("y/N") || confirm.downcase.eql?("no") || confirm.downcase.eql?("n") then
+      res = false
+    else
+      say "Please enter \"yes\" or \"no\"."
+    end
+  end
+  return res
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: cxx
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+  prerelease: 
+platform: ruby
+authors:
+- christian koestlin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cxxproject
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ruby-based dsl for cxxproject
+email: christian.koestlin@gmail.com
+executables:
+- cxx
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Rakefile.rb
+- bin/cxx
+- cxx.gemspec
+- lib/cxx.rb
+- lib/cxx/eval_context.rb
+- lib/cxx/wizard/Rakefile.rb.template
+- lib/cxx/wizard/project.rb.template
+- lib/cxx/wizard/project_wizard.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: defines the method cxx_configuration
+test_files: []