ritsu 0.1.0

data/README.md

@@ -0,0 +1,96 @@
+# Ritsu
+
+Ritsu helps you with C/C++ software development. It provides you with a
+domain specific language to specify a C/C++ project, and then automates
+build project generation with the help of CMake.
+
+## Using
+
+### Generate a Project
+
+Run 
+
+    ritsu my_project
+     
+in command prompt to generate a project.
+This will generate directory with the following contents:
+
+    my_project
+      build
+      meta
+        project.rb
+      src
+        cmake_modules
+        --empty--
+      Thorfile
+
+### Specifying the Project
+      
+The file <tt>meta/project.rb</tt> specifies the project, and its
+content is initially as follows.
+
+    require 'ritsu'
+    
+    Ritsu::Project.create('my_project') do |p|
+    
+      ##################
+      # YOUR CODE HERE #
+      ##################
+    
+    end
+    
+You now can populate the <tt>src</tt> directory with your C/C++ source
+and header files. For examples:
+
+    my_project
+      build
+      meta
+        project.rb
+      src
+        cmake_modules
+        my_program
+          lib.cpp
+          lib.h
+          main.cpp
+      Thorfile
+
+
+Then, you can specify targets to build as follows:
+
+    require 'ritsu'
+    
+    Ritsu::Project.create('my_project') do |p|
+      p.add_executable('my_program') do |e|
+        e.add_cpp_file 'main.cpp'
+        e.add_header_file 'lib.h'
+        e.add_cpp_file 'lib.cpp'
+      end
+    end
+
+As you can see, for each target (an executable or a library), 
+you have to create a directory under <tt>src</tt>, which bears the 
+same name as the project. The file names used in the <tt>add_cpp_file</tt>
+and <tt>add_header_file</tt> commands  are relative to the directory of the target. 
+You can bypass this behavior though.
+
+### Building
+
+To build the project, you first need to update the source files and
+the <tt>CMakeLists.txt</tt> files for the project and for its targets. 
+This is done by running a Thor command in the project directory.
+
+    thor my_project:update_src
+    
+The source files and <tt>CMakeList</tt> files are generated if they are 
+not present. From this point, you can either run cmake to 
+generate platform-specific build scripts, or run
+
+    thor my_project:cmake
+    
+which will create an out-of-source build scripts in the <tt>build</tt> directory.
+The action
+
+    thor my_project:update
+    
+combines the first two steps in one shot. Now, use your platform-specific 
+tool to build the project.

data/Thorfile

@@ -0,0 +1,95 @@
+# enconding: utf-8
+
+require 'rubygems'
+require 'thor/rake_compat'
+require 'rake/testtask'
+require 'rake'
+begin
+  require 'yard'
+rescue LoadError
+end
+
+GEM_NAME = 'ritsu'
+EXTRA_RDOC_FILES = FileList.new('*') do |list|
+  list.exclude(/(^|[^.a-z])[a-z]+/)
+  list.exclude('TODO')
+end.to_a + ['Thorfile']
+
+class Default < Thor
+  include Thor::RakeCompat
+    
+  Rake::TestTask.new do |t|
+    t.libs << 'lib'
+    test_files = FileList['test/**/*_test.rb']
+    t.test_files = test_files
+    t.verbose = true
+  end
+
+  if defined?(RDoc)
+    RDoc::Task.new do |rdoc|
+      rdoc.main = "README.rdoc"
+      rdoc.rdoc_dir = "rdoc"
+      rdoc.title = GEM_NAME
+      rdoc.rdoc_files.include(*EXTRA_RDOC_FILES)
+      rdoc.rdoc_files.include('lib/**/*.rb')
+      rdoc.options << '--line-numbers' << '--inline-source'
+    end
+  end
+  
+  YARD::Rake::YardocTask.new do |t|
+    t.files = FileList.new('lib/**/*.rb').to_a + EXTRA_RDOC_FILES
+    t.options << '--incremental' if Rake.application.top_level_tasks.include?('redoc')
+    #t.options += FileList.new(scope('yard/*.rb')).to_a.map {|f| ['-e', f]}.flatten
+    files = FileList.new('doc-src/*').to_a.sort_by {|s| s.size} + %w[VERSION]
+    t.options << '--files' << files.join(',')
+    #t.options << '--template-path' << scope('yard')
+    t.options << '--title' << ENV["YARD_TITLE"] if ENV["YARD_TITLE"]
+  end
+  
+  desc "doc", "Generate YARD Documentation"
+  def doc
+    yard
+  end
+  
+  begin
+    require 'jeweler'
+    Jeweler::Tasks.new do |s|
+      s.name = GEM_NAME
+      s.version = File.read(File.dirname(__FILE__) + '/VERSION').strip
+      s.rubyforge_project = "ritsu"
+      s.platform = Gem::Platform::RUBY
+      s.summary = "A code generation system that facilitates building C/C++ software with the help of CMake and Doxygen"
+      s.email = "dragonmeteor@gmail.com"
+      s.homepage = "http://github.com/dragonmeteor/ritsu"
+      s.description = "A code generation system that facilitates building C/C++ software with the help of CMake and Doxygen"
+      s.authors = ['dragonmeteor']
+      
+      s.has_rdoc = true
+      s.extra_rdoc_files = EXTRA_RDOC_FILES
+      s.rdoc_options += [
+        '--title', 'Ritsu',
+        '--main', 'README.md',
+        '--line-numbers',
+        '--inline-source'
+       ]
+      
+      s.require_path = 'lib'
+      s.bindir = "bin"
+      s.executables = %w( ritsu )
+      s.files = s.extra_rdoc_files + Dir.glob("{bin,lib}/**/*")
+      s.test_files.include 'test/**/*'
+      s.test_files.exclude 'test/**/output/**'
+      
+      s.add_runtime_dependency 'thor', '>= 0.13.4'
+      s.add_runtime_dependency 'activesupport', '>= 2.3.5'
+      
+      s.add_development_dependency 'jeweler', '>= 1.4.0'
+      s.add_development_dependency 'yard', '>= 0.5.3'
+      s.add_development_dependency 'maruku', '>= 0.5.9'
+    end
+
+    Jeweler::GemcutterTasks.new
+  rescue LoadError
+    puts "Jeweler, or one of its dependencies, is not available. Install it with: gem install jeweler"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/ritsu

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# The command line Ritsu generator.
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+require 'ritsu'
+require 'optparse'
+
+options = {:generator => "default"}
+OptionParser.new do |opts|
+  opts.banner = "Usage: ritsu PROJECT_NAME [OPTIONS]"
+  opts.on("-g", "--generator GENERATOR", "name of the generator to use") do |generator|
+    options[:generator] = generator
+  end
+  
+  opts.parse!
+  if ARGV.length < 1
+    puts opts
+    exit
+  end
+end
+
+generator_class = Ritsu::ProjectGenerator.generator_classes[options[:generator]]
+
+if generator_class.nil?
+  puts "there is no generator with name '#{options[:generator]}'"
+else
+  begin
+    generator_class.new.generate(ARGV[0], '.', options)
+  rescue Exception => e
+    puts e
+  end
+end

data/lib/ritsu/block.rb

@@ -0,0 +1,259 @@
+require 'rubygems'
+require 'active_support/core_ext/string/starts_ends_with'
+require File.dirname(__FILE__) + '/utility/check_upon_add_set'
+require File.dirname(__FILE__) + '/utility/files'
+require File.dirname(__FILE__) + '/utility/strings'
+
+module Ritsu
+  module BlockMixin
+    attr_reader :id
+    attr_accessor :contents
+    attr_accessor :local_indentation
+    attr_accessor :indent_level
+    attr_accessor :indent_length
+    
+    def initialize_block_mixin(id = nil, options={})
+      options = {
+        :contents => [],
+        :local_indentation => "", 
+        :indent_length=>4
+      }.merge(options)
+      
+      @id = id
+      @contents = options[:contents]
+      @local_indentation = options[:local_indentation]
+      @indent_length = options[:indent_length]
+      @indent_level = 0
+    end
+    
+    def add_line(line)
+      contents << " " * (indent_level * indent_length) + line
+    end
+    
+    def add_new_line
+      add_line("")
+    end
+    
+    protected
+    def add_block_structure(block)
+      block.local_indentation = block.local_indentation + " " * (indent_level * indent_length)
+      contents << block
+    end
+    
+    def add_line_or_other_content(content)
+      if content.kind_of?(String)
+        add_line(content)
+      else
+        contents << content
+      end
+    end
+    
+    public
+    def clear_contents
+      contents.clear
+    end
+    
+    def indent
+      @indent_level += 1
+    end
+    
+    def outdent
+      @indent_level -= 1
+    end
+    
+    def block_structure?
+      true
+    end
+  end
+  
+  class Block
+    include BlockMixin
+    
+    attr_accessor :block_start_prefix
+    attr_accessor :block_end_prefix
+        
+    def initialize(id = nil, options={})
+      options = {
+        :block_start_prefix => "//<<",
+        :block_end_prefix => "//>>"
+      }.merge(options)
+
+      @block_start_prefix = options[:block_start_prefix]
+      @block_end_prefix = options[:block_end_prefix]
+      
+      initialize_block_mixin(id, options)
+    end
+    
+    def self.extract_block_id(str, prefix)
+      str.strip.slice((prefix.length)..-1).strip
+    end
+    
+    def extract_block_id(str, prefix)
+      Block.extract_block_id(str, prefix)
+    end
+    
+    def parse_lines(lines, options={})
+      options = {
+        :block_start_prefix => block_start_prefix,
+        :block_end_prefix => block_end_prefix
+      }.merge(options)
+      @block_start_prefix = options[:block_start_prefix]
+      @block_end_prefix = options[:block_end_prefix]
+      
+      block_stack = [self]
+      global_indentation_length = 0
+      
+      get_local_indentation = Proc.new do |line|
+        leading_spaces_length = Ritsu::Utility::Strings.leading_spaces(line, options).length
+        remaining_space_length = leading_spaces_length - global_indentation_length
+        if remaining_space_length < 0 then remaining_space_length = 0 end
+        " " * remaining_space_length
+      end
+      
+      append_line = Proc.new do |line|
+        block_stack.last.contents << (get_local_indentation.call(line) + line.lstrip)
+      end
+      
+      lines.each do |line|
+        if line.strip.starts_with?(block_start_prefix)
+          id = extract_block_id(line, block_start_prefix)
+          local_indentation = get_local_indentation.call(line)
+          
+          options[:local_indentation] = local_indentation
+          block = Block.new(id, options)
+          block_stack.last.contents << block
+          block_stack.push(block)
+          global_indentation_length += block.local_indentation.length
+        elsif line.strip.starts_with?(block_end_prefix)
+          id = extract_block_id(line, block_end_prefix)
+          if block_stack.last.id == id
+            block = block_stack.pop()
+            global_indentation_length -= block.local_indentation.length
+          else
+            append_line.call(line)
+          end
+        else
+          append_line.call(line)
+        end
+      end
+      
+      if block_stack.length != 1
+        raise ArgumentError.new("error in input. some blocks are malformed")
+      end
+    end
+
+    def parse_string(string, options={})
+      lines = string.rstrip.split("\n")
+      parse_lines(lines, options)
+    end
+    
+    def parse_file(filename, options={})
+      text = Ritsu::Utility::Files.read(filename)
+      parse_string(text, options)
+    end
+    
+    ##
+    # In all case, the generated string shall have no trailing whitespaces.
+    def to_s(options={})
+      options = {:no_delimiter => false, :indentation => ""}.merge(options)
+      no_delimiter = options.delete(:no_delimiter)
+      indentation = options.delete(:indentation)
+      
+      io = StringIO.new
+      io << indentation + local_indentation + block_start_prefix + " " + id + "\n" unless no_delimiter
+      contents.each do |content|
+        if content.kind_of?(Block)
+          io << content.to_s({:indentation=>indentation+local_indentation}.merge(options)) + "\n"
+        else
+          io << indentation + local_indentation + content.to_s + "\n"
+        end
+      end
+      io << indentation + local_indentation + block_end_prefix + " " + id unless no_delimiter
+      
+      io.string.rstrip
+    end
+    
+    def write_to_file(filename, options={})
+      options = {:no_delimiter => true}.merge(options)
+      
+      File.open(filename, "w") do |f|
+        f.write(to_s(options))
+      end
+    end
+    
+    def self.parse(*args)
+      if args.length > 2
+        raise ArgumentError.new("only at most 2 arguments, the second one is a hash, are accepted")
+      end
+      options = {}
+      
+      prepare_options_from_kth_arg = Proc.new do |k|
+        options = options.merge(args[k]) if (args.length > k)
+      end
+      
+      block = Block.new
+      result = case args[0]
+      when Array
+        prepare_options_from_kth_arg.call(1)
+        block.parse_lines(args[0], options)
+      when String
+        prepare_options_from_kth_arg.call(1)
+        block.parse_string(args[0], options)
+      when Hash
+        if filename = args[0].delete(:file)
+          prepare_options_from_kth_arg.call(0)
+          block.parse_file(filename, options)
+        else
+          raise ArgumentError.new("you must specify :file option if the first argument is a hash")
+        end
+      end
+      return block
+    end
+    
+    def child_block_count
+      count = 0
+      contents.each do |content|
+        count += 1 if content.kind_of?(Block)
+      end
+    end
+    
+    ##
+    # @return (Block) the first child block with the given ID. nil if there is no such child block.
+    def child_block_with_id(id)
+      contents.each do |content|
+        if content.kind_of?(Block) and content.id == id
+          return content
+        end
+      end
+      return nil
+    end
+    
+    def child_blocks
+      contents.select {|x| x.kind_of?(Block)}
+    end
+    
+    ##
+    # @return (Integer) the position of the child block with the given ID in the contents array. 
+    #   nil if there is no such child block.
+    def child_block_with_id_position(id)
+      contents.length.times do |i|
+        if contents[i].kind_of?(Block) and contents[i].id == id
+          return i
+        end
+      end
+      return nil
+    end
+    
+    def add_block(block)
+      add_block_structure(block)
+    end
+    
+    def add_content(content)
+      if content.kind_of?(Block)
+        add_block(content)
+      else
+        add_line_or_other_content(content)
+      end
+    end
+  end
+end

data/lib/ritsu/ext/test_case.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+
+module Test
+  module Unit
+    class TestCase
+      def self.must(name, &block)
+        test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+        defined = instance_method(test_name) rescue false
+        raise "#{test_name} is already defined in #{self}" if defined
+        if block_given?
+          define_method(test_name, &block)
+        else
+          define_method(test_name) do
+            flunk "No implementation provided for #{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ritsu/external_library.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'active_support'
+require File.dirname(__FILE__) + '/utility/accessors'
+require File.dirname(__FILE__) + '/utility/instance_set'
+
+module Ritsu
+  class ExternalLibrary
+    include Ritsu::Utility::Accessors
+    include Ritsu::Utility::InstanceSet
+    
+    attr_reader :name
+    attr_accessor :cmake_name
+    attr_accessor :cmake_find_script
+    attr_accessor :cmake_depend_script
+    
+    attr_method :cmake_name
+    attr_method :cmake_find_script
+    attr_method :cmake_depend_script
+    
+    def initialize(name, options={})
+      options = {
+        :cmake_name => '',
+        :cmake_find_script => '',
+        :cmake_depend_script => ''}.merge(options)
+      @name = name
+      @cmake_name = options[:cmake_name]
+      @cmake_find_script = options[:cmake_find_script]
+      @cmake_depend_script = options[:cmake_depend_script]
+      ExternalLibrary.instances << self
+    end
+    
+    def self.validate_instance(instance)
+      if instances.select { |x| x.name == instance.name }.length > 0
+        raise ArgumentError.new "external library with name '#{instance.name}' already exists"
+      end
+    end
+    
+    def self.find_by_name(name)
+      instances.each do |instance|
+        if instance.name == name
+          return instance
+        end
+      end
+      return nil
+    end
+  end
+end

data/lib/ritsu/project.rb

@@ -0,0 +1,89 @@
+require 'rubygems'
+require 'active_support'
+require File.dirname(__FILE__) + '/external_library'
+require File.dirname(__FILE__) + '/utility/single_instance'
+require File.dirname(__FILE__) + '/utility/strings'
+require File.dirname(__FILE__) + '/src_files/project_cmake_lists'
+require File.dirname(__FILE__) + '/src_files/project_config_header_file'
+require File.dirname(__FILE__) + '/src_files/project_config_header_template_file'
+
+module Ritsu
+  class Project
+    include Ritsu::Utility::SingleInstance
+    include Ritsu::Utility::Strings
+    
+    attr_reader :name
+    attr_reader :targets
+    attr_reader :external_libraries
+    attr_reader :src_files
+    attr_accessor :project_dir
+    attr_reader :cmake_lists
+    attr_reader :config_header_file
+    attr_reader :config_header_template_file
+    
+    def initialize_instance(name)
+      if !is_c_name?(name)
+        raise ArgumentError.new(
+          "the project name must be a valid C name")
+      end
+      
+      @name = name
+      @targets = Set.new
+      @external_libraries = Set.new
+      @src_files = Set.new
+      @project_dir = File.expand_path('.')
+      
+      @cmake_lists = Ritsu::SrcFiles::ProjectCmakeLists.new(self)
+      @config_header_file = Ritsu::SrcFiles::ProjectConfigHeaderFile.new(self)
+      @config_header_template_file = Ritsu::SrcFiles::ProjectConfigHeaderTemplateFile.new(self)
+    end
+    
+    def self.create(name)
+      project = Project.new(name)
+      yield project if block_given?
+      project
+    end
+    
+    def add_external_library(name)
+      library = ExternalLibrary.new(name)
+      yield library if block_given?
+      @external_libraries << library
+    end
+    
+    def project
+      self
+    end
+    
+    def src_dir
+      project_dir + "/src"
+    end
+    
+    def compute_src_path(path, options={})
+      options = {:relative_to => :src}.merge(options)
+      case options[:reltavie_to]
+      when :src
+        path
+      when :absolute
+        src_dir = Pathname.new(self.src_dir)
+        input_path = Pathname.new(path)
+        input_path.relative_path_from(src_dir).to_s
+      else
+        raise ArgumentError.new("option :relative_to must be either :src or :absolute")
+      end
+    end
+    
+    def include_file(filename, options={})
+      file_content = Ritsu::Utility::Files.read(filename)
+      instance_eval(file_content)
+    end
+    
+    def update
+      src_files.each do |src_file|
+        src_file.update
+      end
+      targets.each do |target|
+        target.update
+      end
+    end
+  end
+end

data/lib/ritsu/project_generator.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/utility/file_robot'
+require File.dirname(__FILE__) + '/utility/instance_set'
+require File.dirname(__FILE__) + '/utility/strings'
+
+module Ritsu
+  class ProjectGenerator
+    attr_reader :name
+    
+    def self.generator_classes
+      @generator_classes ||= {}
+    end
+    
+    def self.is_valid_generator_name?(name)
+      Ritsu::Utility::Strings::is_c_name?(name)
+    end
+    
+    def initialize(name)
+      if !ProjectGenerator.is_valid_generator_name?(name)
+        raise ArgumentError.new("'#{name}' is not a valid project name (i.e., a C name)")
+      end
+      @name = name
+    end
+    
+    def self.validate_instance(instance)
+      if instances.select { |x| x.name == instance.name }.length > 0
+        raise ArgumentError.new("project generator with name '#{instance.name}' already exists")
+      end
+    end
+    
+    def generate(*args)
+      raise NotImplementedError.new
+    end
+  end
+end