ritsu 0.1.0

data/lib/ritsu/template_policies.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/template'
+
+module Ritsu::TemplatePolicies
+  module StrictBlockMatchingButLeaveUserTextBe
+    def update_block(block, options={})
+      child_blocks = block.child_blocks
+      index = 0
+      child_templates.each do |child_template|
+        while index < child_blocks.length && child_blocks[index].id != child_template.id
+          index += 1
+        end
+        if index >= child_blocks.length
+          if child_blocks.select {|x| x.id == child_template.id}
+            raise ArgumentError.new("block with id '#{child_template.id}' appears out of order")
+          else
+            raise ArgumentError.new("cannot find block with id '#{child_template.id}'")
+          end
+        end
+        child_template.update_block(child_blocks[index])
+        index += 1
+      end
+    end
+  end
+  
+  module Blank
+    def update_block(block, options={})
+      block.contents.clear
+    end
+  end
+  
+  module DoNotUpdate
+    def update_block(block, options={})
+    end
+  end
+  
+  module Overwrite
+    def overwrite_block(block, options={})
+      block.clear_contents
+      contents.each do |content|
+        if !content.kind_of?(Ritsu::Template)
+          block.add_content content
+        else
+          block.add_content(content.create_block(options))
+        end
+      end
+    end
+    
+    def update_block(block, options={})
+      overwrite_block(block, options)
+    end
+  end
+  
+  module FlexibleBlockMatching
+    ##
+    # @param (Block) a block
+    # @return (Hash) a hash mapping each child template to a child block with the same id.
+    #   If there is no such child block, the child template is mapped to nil.
+    def match_child_blocks(block)
+      child_blocks = block.child_blocks
+      matching_child_blocks = {}
+      child_templates.each do |child_template|
+        matching = nil
+        child_blocks.each do |child_block|
+          if child_template.id == child_block.id
+            matching = child_block
+            break
+          end
+        end
+        child_blocks.delete(matching) unless matching.nil?
+        matching_child_blocks[child_template] = matching
+      end
+      matching_child_blocks
+    end
+  end
+  
+  module FlexibleBlockMatchingAndCreateMissingBlocksButIgnoreUserText
+    include FlexibleBlockMatching
+    
+    def update_block(block, options={})
+      matching_child_blocks = match_child_blocks(block)
+      
+      block.contents.clear
+      contents.each do |content|
+        if content.kind_of?(Template)
+          if matching_child_blocks[content].nil?
+            block.contents << content.create_block(options)
+          else
+            matching = matching_child_blocks[content]
+            content.update_block(matching)
+            block.contents << matching
+          end
+        else
+          block.contents << content
+        end
+      end
+    end
+  end
+  
+  module FlexibleBlockMatchingAndCreateMissingBlockButLeaveUserTextBe
+    include FlexibleBlockMatching
+    
+    def update_block(block, options={})
+      options = {:new_line_after_block => true}.merge(options)
+      matching_child_blocks = match_child_blocks(block)
+      
+      child_templates.each do |child_template|
+        if matching_child_blocks[child_template].nil?
+          new_block = child_template.create_block(options)
+          
+          position = position_to_insert(block, new_block)
+          if position
+            block.contents.insert(position, new_block)
+            if options[:new_line_after_block]
+              block.contents.insert(position+1, "")
+            end
+          else
+            raise ArgumentError.new("cannot find position to insert '#{new_block.name}'")
+          end
+        else
+          matching = matching_child_blocks[child_template]
+          child_template.update_block(matching)
+        end
+      end
+    end
+    
+    ##
+    # @return (Integer) the position in block.contents to
+    #  insert the given new block
+    def position_to_insert(block, new_block)
+      raise NotImplmentedError
+    end
+  end
+end

data/lib/ritsu/test_helpers.rb

@@ -0,0 +1,124 @@
+require 'test/unit'
+require File.dirname(__FILE__) + "/target"
+require File.dirname(__FILE__) + "/src_file"
+require File.dirname(__FILE__) + "/external_library"
+require File.dirname(__FILE__) + "/project"
+
+module Ritsu
+  module SetupProjectAndClearEverythingElse
+    def setup_project(name='project')
+      Ritsu::Target.instances.clear
+      Ritsu::SrcFile.instances.clear
+      Ritsu::ExternalLibrary.instances.clear
+      @project = Ritsu::Project.create(name)
+    end
+  
+    def setup
+      setup_project
+    end
+  end
+
+  module TestCaseWithFileTestData
+    module ClassMethods
+      def file_test(name, &block)
+        case_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+        if !Ritsu::Utility::Strings::is_c_name?(case_name.to_s)
+          raise "'#{name}' does not yield a valid test case name (i.e., a C name)"
+        end
+        defined = instance_method(case_name) rescue false
+        raise "#{case_name} is already defined in #{self}" if defined
+        if block_given?
+          define_method(case_name) do
+            init_data_dir
+            instance_eval(&block)
+          end
+        else
+          define_method(case_name) do
+            flunk "No implmentation provided for #{case_name}"
+          end
+        end
+      end
+    end
+  
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+    def init_data_dir
+      FileUtils.mkdir_p(data_dir)
+      FileUtils.mkdir_p(static_dir)
+      FileUtils.mkdir_p(output_dir)
+      FileUtils.rm_r(Dir.glob(output_dir + '/*'), :force=>true)
+    end
+  
+    def data_dir
+      raise NotImplementedError.new
+    end
+  
+    def data_path(path)
+      data_dir + '/' + path
+    end
+    
+    def output_dir
+      data_dir + '/output'
+    end
+  
+    def output_path(path)
+      output_dir + '/' + path
+    end
+  
+    def static_dir
+      data_dir + '/static'
+    end
+  
+    def static_path(path)
+      static_dir + '/' + path
+    end
+  
+    def assert_file_exists(filename)
+      assert_block "#{filename} must exists" do
+        File.exists?(filename)
+      end
+    end
+  
+    def assert_file_not_exist(filename)
+      assert_block "#{filename} must not exist" do
+        !File.exists?(filename)
+      end
+    end
+  
+    def assert_data_file_exists(filename)
+      assert_file_exists(data_path(filename))
+    end
+  
+    def assert_data_file_not_exist(filename)
+      assert_file_not_exist(data_path(filename))
+    end
+  
+    def assert_output_file_exists(filename)
+      assert_file_exists(output_path(filename))
+    end
+  
+    def assert_output_file_not_exist(filename)
+      assert_file_not_exist(output_path(filename))
+    end
+  
+    def assert_file_content(content, filename)
+      assert_equal content, IO.read(filename)
+        "content of #{filename} differs from expected"
+    end
+  
+    def assert_file_compare(expected_file, actual_file)
+      assert_equal IO.read(expected_file), IO.read(actual_file),
+        "content of #{actual_file} differs from #{expected_file}"
+    end
+  
+    def assert_output_file_compare_to_static(path)
+      assert_file_compare(static_path(path), output_path(path))
+    end
+  
+    def assert_output_file_content(content, path)
+      assert_file_content(content, output_path(path))
+    end
+  end
+end

data/lib/ritsu/thors/default_thor.rb

@@ -0,0 +1,57 @@
+require 'thor'
+require File.dirname(__FILE__) + '/../project'
+require File.dirname(__FILE__) + '/../utility/platform'
+
+module Ritsu::Thors
+  class DefaultThor < Thor
+    desc "update_src", "update all the source files"
+    def update_src
+      Ritsu::Project.instance.update
+    end
+
+    desc "cmake", "run CMake"
+    method_option :generator, :type => :string
+    def cmake
+      prepare_cmake_generator
+            
+      if !File.exists?(File.dirname(__FILE__) + "/build")
+        FileUtils.mkdir_p(File.dirname(__FILE__) + "/build")
+      end
+
+      FileUtils.chdir("build", :verbose => true)
+      system("cmake ../src -G\"#{@cmake_generator}\"")
+    end
+
+    desc "update", "update source files and then run CMake"
+    method_option :generator, :type => :string
+    def update
+      prepare_cmake_generator
+            
+      update_src
+      cmake
+    end
+    
+    protected
+      def prepare_cmake_generator
+        if !options.has_key?(:generator)
+          @cmake_generator = default_cmake_generator(Ritsu::Utility.platform)
+        else
+          @cmake_generator = options[:generator]
+        end
+      end
+      
+      def default_cmake_generator(platform)
+        platform = platform.to_sym
+        case platform
+        when :windows
+          "Visual Studio 9 2008"
+        when :mac
+          "Xcode"
+        when :unix
+          "Unix Makefiles"
+        else
+          raise ArgumentError.new("invalid platform '#{platform.to_s}'")
+        end
+      end
+  end
+end

data/lib/ritsu/thors.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/thors/default_thor'

data/lib/ritsu/utility/accessors.rb

@@ -0,0 +1,30 @@
+module Ritsu
+  module Utility
+    module Accessors
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def attr_method_single(name)
+          name = name.to_s
+          module_eval <<-_RUBY
+            def #{name}(*args)
+              if args.length == 0
+                @#{name} ||= nil
+              elsif args.length == 1
+                @#{name} = args[0]
+              end
+            end
+          _RUBY
+        end
+        
+        def attr_method(*names)
+          names.each do |name|
+            attr_method_single(name)
+          end
+        end
+      end      
+    end
+  end
+end

data/lib/ritsu/utility/check_upon_add_set.rb

@@ -0,0 +1,35 @@
+require 'set'
+
+module Ritsu
+  module Utility
+    class CheckUponAddSet < Set
+      def initialize(*args, &block)
+        if block_given?
+          @check_block = block
+        else
+          @check_block = Proc.new { }
+        end
+        super(*args)
+      end
+    
+      def <<(x)
+        @check_block.call(self, x)
+        super(x)
+      end
+    
+      def add(x)
+        @check_block.call(self, x)
+        super(x)
+      end
+    
+      def add?(x)
+        begin
+          @check_block.call(self, x)
+          super(x)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ritsu/utility/file_robot.rb

@@ -0,0 +1,129 @@
+require 'fileutils'
+require 'singleton'
+require File.dirname(__FILE__) + '/../utility/simple_io'
+
+module Ritsu
+  module Utility
+    class FileRobot
+      include Singleton
+      def self.v; instance end
+    
+      def self.method_missing(symbol, *args, &block)
+        instance.send(symbol, *args, &block)
+      end
+    
+      attr_accessor :force
+      attr_reader :io
+    
+      def initialize
+        @io = SimpleIO.new
+        @force = false
+      end
+    
+      def output; io.output end
+      def output=(value); io.output = value end
+      def input; io.input end
+      def input=(value); io.input = value end
+      def quiet; io.quiet end
+      def quiet=(value); io.quiet = value end
+    
+      def quietly(&block)
+        old_quiet = self.quiet
+        self.quiet = true
+        block.call
+        self.quiet = old_quiet
+      end
+    
+      def verbosely(&block)
+        old_quiet = self.quiet
+        self.quiet = false
+        block.call
+        self.quiet = old_quiet
+      end
+    
+      def forcefully(&block)
+        old_force = self.force
+        self.force = true
+        block.call
+        self.force = old_force
+      end
+    
+      def create_dir(dir_name, options={})
+        options = {:echo_exists=>true}.merge(options)
+        if File.exists?(dir_name)
+          if options[:echo_exists]
+            io.log('exist', dir_name)
+          end
+        else
+          FileUtils.mkdir_p(dir_name)
+          io.log('create', dir_name)
+        end
+      end
+    
+      def create_file(filename, content="")
+        do_create_file = Proc.new do
+          File.open(filename, "w") { |f| f.write content }
+        end
+      
+        do_overwrite = Proc.new do
+          do_create_file.call
+          io.log('overwrite', filename)
+        end
+      
+        create_dir(File.dirname(filename), :echo_exists=>false)
+        if File.exists?(filename)
+          if force
+            do_overwrite.call
+          else
+            answer = io.ask_yes_no_all("overwrite #{filename}?")
+            case answer
+            when :yes
+              do_overwrite.call
+            when :no
+              io.log('exist', filename)
+            when :all
+              force = true
+              do_overwrite.call
+            end
+          end
+        else
+          do_create_file.call
+          io.log('create', filename)
+        end
+      end
+    
+      def remove_dir(dirname)      
+        if !File.exist?(dirname)
+          io.log("not exist", dirname)
+        elsif !File.directory?(dirname)
+          io.log("not dir", dirname)
+        else
+          begin
+            Dir.glob(dirname + "/*") { throw "not empty" }
+            is_empty = true
+          rescue
+            is_empty = false
+          end
+        
+          if !is_empty
+            io.log('not empty', dirname)
+          elsif
+            FileUtils.remove_dir(dirname)
+            io.log("remove", dirname)
+          end
+        end
+      end
+    
+      def remove_file(filename)
+        if !File.exists?(filename)
+          io.log("not exist", filename)
+        elsif !File.file?(filename)
+          io.log("not file", filename)
+        else
+          FileUtils.remove_file(filename)
+          io.log("remove", filename)
+        end
+      end
+    end
+  end
+end

data/lib/ritsu/utility/files.rb

@@ -0,0 +1,13 @@
+module Ritsu
+  module Utility
+    module Files
+      def read(filename)
+        f = File.new(filename)
+        result = f.read
+        f.close
+        result
+      end
+      module_function :read
+    end
+  end
+end

data/lib/ritsu/utility/instance_dependencies.rb

@@ -0,0 +1,113 @@
+require 'rubygems'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/inflector'
+require File.dirname(__FILE__) + "/instance_set"
+
+module Ritsu
+  module Utility
+    module InstanceDependencies
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def dependencies_between(name)
+          name = name.to_s.singularize
+          dependency_set_name = "dependency_#{name.pluralize}"
+          
+          module_eval <<-RUBY
+            attr_reader :#{dependency_set_name}
+            attr_accessor :topological_order
+            
+            def #{dependency_set_name}
+              @#{dependency_set_name} ||= Ritsu::Utility::CheckUponAddSet.new do |s,dependency|
+                validate_dependency_#{name}(dependency)
+                self.class.invalidate_topological_orders
+              end
+            end
+            
+            def depends_directly_on_#{name}?(instance)
+              #{dependency_set_name}.include?(instance)
+            end
+            
+            def depends_on_#{name}?(instance)
+              visited = Set.new [self]
+              queue = [self]
+
+              # Perform a breadth first search
+              while !visited.include?(instance) && !queue.empty?
+                u = queue.shift
+                u.#{dependency_set_name}.each do |v|
+                  if !visited.include?(v)
+                    queue << v
+                    visited << v
+                  end
+                end
+              end
+
+              visited.delete(self)
+              visited.include?(instance)
+            end
+            
+            def validate_dependency_#{name}(instance)
+              instance_name = instance.name
+              if instance == self
+                raise ArgumentError.new("'\#{instance.name}' is the same as the dependent #{name}")
+              end
+              if instance.depends_on_#{name}?(self)
+                raise ArgumentError.new("including '\#{instance.name}' will create a circular dependency")
+              end
+              if !instance.can_be_depended_on?
+                raise ArgumentError.new("'\#{instance.name}' cannot be dependend on")
+              end
+            end
+            
+            def self.recompute_topological_orders
+              indegrees = {}
+              instances.each { |instance| indegrees[instance] = 0 }
+              instances.each do |instance|
+                instance.#{dependency_set_name}.each do |dependency|
+                  indegrees[dependency] += 1
+                end
+              end
+
+              last_order = instances.length-1
+              indegree_zero = instances.select { |instance| indegrees[instance] == 0 }
+              while !indegree_zero.empty?
+                u = indegree_zero.shift
+                u.topological_order = last_order
+                last_order -= 1
+                u.#{dependency_set_name}.each do |v|
+                  indegrees[v] -= 1
+                  if indegrees[v] == 0
+                    indegree_zero << v
+                  end
+                end
+              end
+              
+              @topological_orders_computed = true
+            end
+            
+            def self.topological_orders_computed?
+              @topological_order_computed ||= false
+            end
+
+            def self.compute_topological_orders
+              if !topological_orders_computed?
+                recompute_topological_orders
+              end
+            end
+
+            def self.invalidate_topological_orders
+              @topological_order_computed = false
+            end
+            
+            def can_be_depended_on?
+              raise NotImplementedError.new
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/ritsu/utility/instance_set.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../utility/check_upon_add_set'
+
+module Ritsu
+  module Utility
+    module InstanceSet      
+      module ClassMethods        
+        def instances
+          @instances ||= Ritsu::Utility::CheckUponAddSet.new do |s, instance|
+            validate_instance(instance)
+          end
+        end
+        
+        def validate_instance(instance)
+        end
+      end
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      def initialize(*args, &block)
+        self.class.instances << self
+      end
+      
+      def initialize_instance(*args, &block)
+      end
+    end
+  end
+end

data/lib/ritsu/utility/platform.rb

@@ -0,0 +1,21 @@
+module Ritsu
+  module Utility
+    def platform
+      case RUBY_PLATFORM.downcase
+      when /linux|bsd|solaris|hpux/
+        :unix
+      when /darwin/
+        :mac
+      when /mswin32|mingw32|bccwin32/
+        :windows
+      when /cygwin/
+        :cygwin
+      when /java/
+        :java
+      else
+        :other
+      end
+    end
+    module_function :platform
+  end
+end