ritsu 0.1.0

data/lib/ritsu/utility/simple_io.rb

@@ -0,0 +1,65 @@
+module Ritsu
+  module Utility
+    ##
+    # This class is lifted from rubigen's SimpleLogger
+    class SimpleIO    
+      attr_accessor :input
+      attr_accessor :output
+      attr_accessor :quiet
+
+      def initialize(input = $stdin, output = $stdout)
+        @input = input
+        @output = output
+        @quiet = false
+        @level = 0
+      end
+
+      def log(status, message, &block)
+        @output.print("%12s %s%s\n" % [status, ' ' * @level, message]) unless quiet
+        indent(&block) if block_given?
+      end
+
+      def indent(&block)
+        @level += 1
+        if block_given?
+          begin
+            block.call
+          ensure
+            outdent
+          end
+        end
+      end
+
+      def outdent
+        @level -= 1
+        if block_given?
+          begin
+            block.call
+          ensure
+            indent
+          end
+        end
+      end
+    
+      def ask_yes_no_all(message)
+        @output.print("#{message} (yes/no/all): ")
+        answer = @input.gets.strip
+        case answer
+        when /^y(es)?$/i
+          return :yes
+        when /^no?$/i
+          return :no
+        when /^a(ll)?$/i
+          return :all
+        else
+          ask_yes_no_all(message)
+        end
+      end
+
+      private
+        def method_missing(method, *args, &block)
+          log(method.to_s, args.first, &block)
+        end
+    end
+  end
+end

data/lib/ritsu/utility/single_instance.rb

@@ -0,0 +1,34 @@
+module Ritsu
+  module Utility
+    module SingleInstance
+      module ClassMethods
+        def instance
+          @instance ||= nil
+        end
+        
+        def set_instance(instance)
+          validate_instance(instance)
+          @instance = instance
+        end
+        
+        def validate_instance(instance)
+        end
+      end
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      def initialize(*args, &block)
+        initialize_instance(*args, &block)
+        self.class.set_instance(self)
+      end
+      
+      def initialize_instance(*args, &block)
+        if self.class.superclass.method_defined? :initialize_instance
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ritsu/utility/strings.rb

@@ -0,0 +1,41 @@
+module Ritsu
+  module Utility
+    module Strings
+      def is_underscore_case?(str)
+        str =~ /^[a-z_][0-9a-z_]*$/
+      end
+      module_function :is_underscore_case?
+
+      def is_c_name?(str)
+        str =~ /^[A-Za-z_]\w*$/
+      end
+      module_function :is_c_name?
+
+      def first(len, str)
+        if str.length > count
+          str[0..(len-1)]
+        else
+          str
+        end
+      end
+      module_function :first
+      
+      def leading_whitespaces(str)
+        /^\s*/.match(str)[0]
+      end
+      module_function :leading_whitespaces
+      
+      def convert_whitespaces_to_spaces(str, options={})
+        options = {:soft_tab => 4}.merge(options)
+        str.sub("\t", " "*options[:soft_tab]).sub(/\n\r/, "")
+      end
+      module_function :convert_whitespaces_to_spaces
+      
+      def leading_spaces(str, options={})
+        Ritsu::Utility::Strings.convert_whitespaces_to_spaces(
+          Ritsu::Utility::Strings.leading_whitespaces(str), options)
+      end
+      module_function :leading_spaces
+    end
+  end
+end

data/lib/ritsu/utility.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/utility/strings'
+require File.dirname(__FILE__) + '/utility/accessors'
+require File.dirname(__FILE__) + '/utility/instance_set'
+require File.dirname(__FILE__) + '/utility/simple_io'
+require File.dirname(__FILE__) + '/utility/file_robot'
+require File.dirname(__FILE__) + '/utility/check_upon_add_set'
+require File.dirname(__FILE__) + '/utility/files'
+require File.dirname(__FILE__) + '/utility/platform'

data/lib/ritsu.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'active_support'
+
+require File.dirname(__FILE__) + '/ritsu/external_library'
+require File.dirname(__FILE__) + '/ritsu/project'
+require File.dirname(__FILE__) + '/ritsu/target'
+require File.dirname(__FILE__) + '/ritsu/src_file'
+require File.dirname(__FILE__) + '/ritsu/block'
+require File.dirname(__FILE__) + '/ritsu/template'
+require File.dirname(__FILE__) + '/ritsu/project_generator'
+
+require File.dirname(__FILE__) + '/ritsu/template_policies'
+require File.dirname(__FILE__) + '/ritsu/targets'
+require File.dirname(__FILE__) + '/ritsu/src_files'
+require File.dirname(__FILE__) + '/ritsu/utility'
+require File.dirname(__FILE__) + '/ritsu/project_generators'
+require File.dirname(__FILE__) + '/ritsu/thors'

data/test/ritsu/block_test.rb

@@ -0,0 +1,197 @@
+require File.dirname(__FILE__) + "/../test_helpers"
+
+class BlockTest < Test::Unit::TestCase
+  include Ritsu::TestCaseWithFileTestData
+  include Ritsu::Utility
+  
+  def data_dir; File.dirname(__FILE__) + "/" + File.basename(__FILE__, ".rb") end
+  
+  must "parse lines with no block content correctly" do
+    block = Ritsu::Block.new
+    block.parse_lines(["abc", "def", "ghi"])
+    assert_equal ["abc", "def", "ghi"], block.contents
+  end
+  
+  BLOCK_A_ARRAY = [
+    "abc",
+    "//<< 123",
+    "def",
+    "//>> 123",
+    "ghi",
+    "jkl",
+    "//<<",
+    "mno",
+    "pqr",
+    "//>>",
+    "stu"
+  ]
+  
+  def check_block_A(block)
+    assert_equal 6, block.contents.length
+    assert_equal "abc", block.contents[0]
+    assert_equal 1, block.contents[1].contents.length
+    assert_equal "def", block.contents[1].contents[0]
+    assert_equal "ghi", block.contents[2]
+    assert_equal "jkl", block.contents[3]
+    assert_equal 2, block.contents[4].contents.length
+    assert_equal "mno", block.contents[4].contents[0]
+    assert_equal "pqr", block.contents[4].contents[1]
+    assert_equal "stu", block.contents[5]
+  end
+  
+  must "parse block delimiter correctly" do
+    block = Ritsu::Block.new
+    block.parse_lines(BLOCK_A_ARRAY)
+    check_block_A(block)    
+  end
+
+  BLOCK_B_ARRAY = [
+    "//<<",
+      "//<<",
+      "//>>",
+
+      "//<<",
+        "//<<",
+        "//>>",
+      "//>>",
+    "//>>",
+    
+    "//<<",
+    "//>>",
+  ]
+  
+  def check_block_B(block)
+    assert_equal 2, block.contents.length
+    assert_equal 2, block.contents[0].contents.length
+    assert_equal 0, block.contents[0].contents[0].contents.length
+    assert_equal 1, block.contents[0].contents[1].contents.length
+    assert_equal 0, block.contents[0].contents[1].contents[0].contents.length
+    assert_equal 0, block.contents[1].contents.length
+  end
+  
+  must "parse nested block correctly" do
+    block = Ritsu::Block.new
+    block.parse_lines(BLOCK_B_ARRAY)
+    check_block_B(block)
+  end
+  
+  must "convert to string correctly" do
+    block = Ritsu::Block.new("123",
+      :contents => [
+        "abc",
+        "def",
+        Ritsu::Block.new("456",
+          :contents => [
+            "ghi"
+          ]
+        ),
+        "jkl"
+      ]
+    )
+    expected_string =
+      "//<< 123\n" +
+      "abc\n" +
+      "def\n" +
+      "//<< 456\n" +
+      "ghi\n" +
+      "//>> 456\n" +
+      "jkl\n" +
+      "//>> 123"
+    assert_equal expected_string, block.to_s
+  end
+  
+  must "convert to string correct when the no_delimiter option is set" do
+    block = Ritsu::Block.new("123", 
+      :contents => [
+        "abc",
+        "def",
+        Ritsu::Block.new("456",
+          :contents => [
+            "ghi"
+          ]
+        ),
+        "jkl"
+      ]
+    )
+    expected_string =
+      "abc\n" +
+      "def\n" +
+      "//<< 456\n" +
+      "ghi\n" +
+      "//>> 456\n" +
+      "jkl"
+    assert_equal expected_string, block.to_s(:no_delimiter=>true)
+  end
+  
+  file_test "write to file" do
+    block = Ritsu::Block.new("123",
+      :contents => [
+        "abc",
+        "def",
+        Ritsu::Block.new("456",
+          :contents => [
+            "ghi"
+          ]
+        ),
+        "jkl"
+      ]
+    )
+    expected_content = 
+      "abc\n" +
+      "def\n" +
+      "//<< 456\n" +
+      "ghi\n" +
+      "//>> 456\n" +
+      "jkl"
+    block.write_to_file(output_path("block.txt"))
+    assert_output_file_content expected_content, "block.txt"
+  end
+  
+  must "Block.parse must work correctly on array" do
+    block = Ritsu::Block.parse(BLOCK_A_ARRAY)
+    check_block_A(block)
+  end
+  
+  must "Block.parse must work correctly on string" do
+    block = Ritsu::Block.parse(BLOCK_A_ARRAY.join("\n"))
+    check_block_A(block)
+  end
+  
+  file_test "Block_dot_parse must work correct on file" do
+    FileRobot.quietly do
+      FileRobot.create_file(output_path("block.txt"), BLOCK_A_ARRAY.join("\n"))
+    end
+    block = Ritsu::Block.parse(:file => output_path("block.txt"))
+    check_block_A(block)
+  end
+  
+  BLOCK_C_ARRAY = [
+    "123",
+    "    //<< abc",
+    "    456",
+    "        //<< def",
+    "           789",
+    "        //>> def",
+    "    //>> abc",
+  ]
+  
+  must "parse indented blocks correctly" do
+    block = Ritsu::Block.parse(BLOCK_C_ARRAY)
+    assert_equal "    ", block.contents[1].local_indentation
+    assert_equal "456", block.contents[1].contents[0]
+    assert_equal "    ", block.contents[1].contents[1].local_indentation
+    assert_equal "   789", block.contents[1].contents[1].contents[0]
+    
+    expected_string = <<-STRING
+123
+    //<< abc
+    456
+        //<< def
+           789
+        //>> def
+    //>> abc
+STRING
+    expected_string.strip!
+    assert_equal expected_string, block.to_s(:no_delimiter=>true)
+  end
+end

data/test/ritsu/external_library_test.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + "/../test_helpers"
+
+class ExternalLibraryTest < Test::Unit::TestCase
+  include Ritsu
+  
+  def setup
+    ExternalLibrary.instances.clear
+  end
+  
+  must "initialize correctly" do
+    qt = ExternalLibrary.new('qt')
+    assert_equal 'qt', qt.name
+    assert_equal '', qt.cmake_name
+    assert_equal '', qt.cmake_depend_script
+    assert_equal '', qt.cmake_find_script
+    assert_equal 1, ExternalLibrary.instances.size
+  end
+  
+  must "be able to use cmake_name, cmake_depend_script, and cmake_find_script methods in instance_eval" do
+    qt = ExternalLibrary.new('qt')
+    qt.instance_eval do
+      cmake_name 'Qt'
+      cmake_depend_script 'abc'
+      cmake_find_script 'def'
+    end
+    assert_equal 'Qt', qt.cmake_name
+    assert_equal 'abc', qt.cmake_depend_script
+    assert_equal 'def', qt.cmake_find_script
+  end
+  
+  must "raise exception if create external library with duplicated names" do
+    ExternalLibrary.new('qt')
+    assert_raises(ArgumentError) do
+      ExternalLibrary.new('qt')
+    end
+  end
+  
+  must "find_by_name correctly" do
+    qt = ExternalLibrary.new('qt')
+    assert_equal qt, ExternalLibrary.find_by_name('qt')
+  end
+end

data/test/ritsu/project_generators/default_generator_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+class DefaultGeneratorTest < Test::Unit::TestCase
+  include Ritsu::TestCaseWithFileTestData
+  include Ritsu::Utility
+  
+  def data_dir; File.dirname(__FILE__) + "/" + File.basename(__FILE__, ".rb") end
+      
+  file_test "generate" do
+    FileRobot.quietly do
+      Ritsu::ProjectGenerators::DefaultGenerator.new.generate('mio', output_dir)
+    end
+    
+    assert_output_file_exists("mio")
+    assert_output_file_exists("mio/build")
+    assert_output_file_exists("mio/src")
+    assert_output_file_exists("mio/meta")
+    assert_output_file_exists("mio/Thorfile")
+    assert_output_file_exists("mio/meta/project.rb")
+    
+    expected_project_rb_content = <<-RUBY
+require 'ritsu'
+
+Ritsu::Project.create('mio') do |p|
+
+  ##################
+  # YOUR CODE HERE #
+  ##################
+
+end
+RUBY
+    assert_output_file_content(expected_project_rb_content, "mio/meta/project.rb")
+  end
+end

data/test/ritsu/project_test.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + "/../test_helpers"
+
+class ProjectTest < Test::Unit::TestCase
+  include Ritsu::TestCaseWithFileTestData
+  include Ritsu::Utility
+  
+  def data_dir; File.dirname(__FILE__) + "/" + File.basename(__FILE__, ".rb") end
+  
+  def setup
+    Ritsu::Target.instances.clear
+    Ritsu::SrcFile.instances.clear
+    Ritsu::ExternalLibrary.instances.clear
+  end
+
+  must "create correctly" do
+    hello = Ritsu::Project.create('hello')
+    assert_equal 'hello', hello.name 
+    assert_equal Set.new, hello.targets
+    assert_equal Set.new, hello.external_libraries
+  end
+  
+  ['53k', 'abc def', '???'].each do |project_name|
+    must "raise exception if project name is #{project_name} (i.e., not a C name)" do
+      assert_raises(ArgumentError) do
+        Ritsu::Project.create(project_name)
+      end
+    end
+  end
+  
+  ['mio', 'MikuMikuDance', '_Something'].each do |project_name|
+    must "not raise exception if project name is #{project_name} (i.e., a valid C name)" do
+      assert_nothing_raised do
+        Ritsu::Project.create(project_name)
+      end
+    end
+  end
+  
+  must "be able to add external libraries" do
+    hello = Ritsu::Project.create('hello') do |p|
+      p.add_external_library 'qt_core' do |e|
+        e.cmake_name '${QT_LIBRARIES}'
+        e.cmake_find_script <<-CMAKE
+FIND_PACKAGE(Qt4 REQUIRED)
+CMAKE
+        e.cmake_depend_script <<-CMAKE
+INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR})
+SET(QT_DONT_USE_QTGUI TRUE)
+CMAKE
+      end
+      p.add_external_library 'qt_core_gui' do |e|
+        e.cmake_name '${QT_LIBRARIES}'
+        e.cmake_find_script <<-CMAKE
+FIND_PACKAGE(Qt4 REQUIRED)
+CMAKE
+        e.cmake_depend_script <<-CMAKE
+INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR})
+CMAKE
+      end
+      p.add_external_library 'qt_core_gui_opengl' do |e|
+        e.cmake_name '${QT_LIBRARIES}'
+        e.cmake_find_script <<-CMAKE
+FIND_PACKAGE(Qt4 REQUIRED)
+CMAKE
+        e.cmake_depend_script <<-CMAKE
+INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR})
+SET(QT_USE_OPENGL TRUE)
+CMAKE
+      end
+    end
+    
+    assert_equal 3, hello.external_libraries.length
+    assert hello.external_libraries.any? { |x| x.name == 'qt_core' }
+    assert hello.external_libraries.any? { |x| x.name == 'qt_core_gui' }
+    assert hello.external_libraries.any? { |x| x.name == 'qt_core_gui_opengl' }
+  end
+  
+  must "be able to add targets" do
+    hello = Ritsu::Project.create('hello') do |p|
+      p.add_executable 'abc'
+      p.add_shared_library 'def'
+      p.add_static_library 'ghi'
+    end
+    
+    assert_equal 3, hello.targets.length
+    assert hello.targets.any? { |x| x.name == 'abc' }
+    assert hello.targets.any? { |x| x.name == 'def' }
+    assert hello.targets.any? { |x| x.name == 'ghi' }
+  end
+  
+  file_test "create config header file" do
+    hello = Ritsu::Project.create('hello')
+    hello.project_dir = output_dir
+    assert hello.respond_to?(:config_header_file)
+    assert hello.src_files.any? {|x| x.src_path != "config.h"}
+    
+    FileRobot.quietly do
+      hello.update
+    end
+    
+    assert_output_file_exists("src/config.h")
+    assert_output_file_content("\n", "src/config.h")
+  end
+  
+  file_test "create config header template file" do
+    hello = Ritsu::Project.create('hello')
+    hello.project_dir = output_dir
+    assert hello.respond_to?(:config_header_template_file)
+    assert hello.src_files.any? {|x| x.src_path != "config.h.in"}
+
+    FileRobot.quietly do
+      hello.update
+    end
+
+    assert_output_file_exists("src/config.h.in")
+    
+    expected_content = <<-TEXT
+#ifndef __PROJECT_CONFIG_H__
+#define __PROJECT_CONFIG_H__
+
+#cmakedefine __WIN_PLATFORM__
+#cmakedefine __MAC_PLATFORM__
+#cmakedefine __UNIX_PLATFORM__
+
+#endif
+TEXT
+    assert_output_file_content("\n", "src/config.h")
+  end
+end

data/test/ritsu/src_file_test.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + "/../test_helpers"
+
+class SrcFileTest < Test::Unit::TestCase
+  include Ritsu::SetupProjectAndClearEverythingElse
+  
+  def self.test_valid_src_path(src_path)
+    must "#{src_path} is a valid source path" do
+      assert Ritsu::SrcFile.is_valid_src_path?(src_path),
+        "#{src_path} must be a valid source path"
+    end
+  end
+  
+  test_valid_src_path "abc.txt"
+  test_valid_src_path "SomeProject/Something_else.cpp"
+  test_valid_src_path "mio/koakuma/shadow_gl_renderer.cpp"
+  test_valid_src_path ".abc"
+  test_valid_src_path "abc-hello.c"
+  
+  def self.test_invalid_src_path(src_path)
+    must "#{src_path} is not a valid source path" do
+      assert !Ritsu::SrcFile.is_valid_src_path?(src_path),
+        "#{src_path} must not be a valid source path"
+    end
+  end
+  
+  test_invalid_src_path "abc def"
+  test_invalid_src_path "/home/one_users/.tmp"
+  test_invalid_src_path ""
+  
+  must "throw exception if a source file with invalid source path is given" do
+    assert_raises ArgumentError do
+      Ritsu::SrcFile.new("abc def", @project) 
+    end
+  end
+  
+  must "throw exception if two source files have duplicated names" do
+    assert_raises ArgumentError do
+      Ritsu::SrcFile.new("abc/abc.txt", @project)
+      Ritsu::SrcFile.new("abc/abc.txt", @project)
+    end
+  end
+  
+  must "now throw exception if source path is a valid source path" do
+    assert_nothing_raised do
+      Ritsu::SrcFile.new("abc/abc.txt", @project)
+    end
+  end
+  
+  must "be added to the owner's src_files array" do
+    abc = Ritsu::SrcFile.new("abc/abc.txt", @project)
+    assert @project.src_files.include?(abc)
+  end
+  
+  must "return its project correctly when owner is the project" do
+    abc = Ritsu::SrcFile.new("abc/abc.txt", @project)
+    assert_equal @project, abc.project
+  end
+  
+  must "return its project correct when owheter is a target" do
+    target = Ritsu::Targets::Executable.new("def")
+    abc = Ritsu::SrcFile.new('abc/abc.txt', target)
+    assert_equal target, abc.owner
+    assert_equal @project, abc.project
+  end
+  
+  must "compute absolute path correctly" do
+    abc = Ritsu::SrcFile.new("abc/abc.txt", @project)
+    assert_equal @project.project_dir + "/src/abc/abc.txt", abc.abs_path
+  end
+end

data/test/ritsu/src_files/cpp_file_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + "/../../test_helpers"
+
+class CppFileTest < Test::Unit::TestCase
+  include Ritsu::SetupProjectAndClearEverythingElse
+  include Ritsu::TestCaseWithFileTestData
+  include Ritsu::Utility
+  
+  def data_dir; File.dirname(__FILE__) + "/" + File.basename(__FILE__, ".rb") end
+  
+  def setup
+    setup_project
+    @project.project_dir = output_dir
+    @target = Ritsu::Targets::Executable.new("abc", :project=>@project)
+  end
+  
+  file_test "create" do
+    @cpp_file = Ritsu::SrcFiles::CppFile.new("abc/def.cpp", @target)
+    FileRobot.quietly do
+      @cpp_file.create
+    end
+    assert_file_exists(@cpp_file.abs_path)
+    assert_file_content("\n", @cpp_file.abs_path)
+  end
+
+  file_test "update_does_nothing" do
+    @header_file = Ritsu::SrcFiles::CppFile.new("abc/def.cpp", @target)
+    FileRobot.quietly do
+      FileRobot.create_file(output_path("src/abc/def.cpp"), "abc")
+      @header_file.update
+    end
+    assert_file_content("abc", @header_file.abs_path)
+  end
+
+  file_test "delete" do
+    @header_file = Ritsu::SrcFiles::CppFile.new("abc/def.cpp", @target)
+    FileRobot.quietly do
+      @header_file.create
+      assert_file_exists(@header_file.abs_path)
+      @header_file.remove
+      assert_file_not_exist(@header_file.abs_path)
+    end
+  end
+end