canoe 0.2.3 → 0.3.1

data/lib/err.rb

@@ -1,7 +1,9 @@
+require_relative "coloring"
+
 module Err
   def warn_on_err(err)
     puts <<~ERR
-           Warning: 
+           #{"Waring: ".yellow}
                #{err}
            try 'canoe help' for more information
          ERR
@@ -9,10 +11,10 @@ module Err
 
   def abort_on_err(err)
     abort <<~ERR
-            Fatal: 
+            #{"Fatal: ".red}
                 #{err}
             try 'canoe help' for more information
-         ERR
+          ERR
   end
 
   module_function :warn_on_err, :abort_on_err

data/lib/source_files.rb

@@ -1,8 +1,11 @@
+##
+# class SourceFiles
+#   A simple class to assist collect all files or some files in a directory.
 class SourceFiles
   class << self
     def get_all(dir, &block)
       @files = []
-      get_all_helper(dir, &block) 
+      get_all_helper(dir, &block)
       @files
     end
 
@@ -16,13 +19,14 @@ class SourceFiles
           else
             @files << "#{file}"
           end
-        end 
+        end
       end
-      
+
       @files
     end
 
     private
+
     def get_all_helper(dir, &block)
       Dir.each_child(dir) do |f|
         file = "#{dir}/#{f}"
@@ -39,4 +43,3 @@ class SourceFiles
     end
   end
 end
-

data/lib/workspace/add.rb

@@ -0,0 +1,27 @@
+class WorkSpace
+  def add(args)
+    args.each do |i|
+      dir = @components
+      filenames = i.split("/")
+      prefix = []
+      filenames.each do |filename|
+        dir += "/#{filename}"
+        prefix << filename
+        unless Dir.exist? dir
+          FileUtils.mkdir dir
+          Dir.chdir(dir) do
+            puts "created " + Dir.pwd.blue
+            create_working_files prefix.join("__"), filename
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def create_working_files(prefix, filename)
+    DefaultFiles.create_cpp filename, @source_suffix, @header_suffix
+    DefaultFiles.create_hpp @name, prefix, filename, @header_suffix
+  end
+end

data/lib/workspace/build.rb

@@ -0,0 +1,131 @@
+class WorkSpace
+  # args are commandline parameters passed to `canoe build`,
+  # could be 'all', 'test', 'target' or empty
+  def build(args)
+    case args[0]
+    when "all"
+      build_all
+    when "test"
+      build_test
+    else
+      build_target
+    end
+  end
+
+  private
+
+  def build_flags(flags, config)
+    config.values.each do |v|
+      case v
+      when String
+        flags << v
+      when Array
+        v.each do |o|
+          flags << o
+        end
+      else
+        abort_on_err "unknown options in config.json, #{v}"
+      end
+    end
+  end
+
+  def build_compiler_from_config
+    Dir.chdir(@workspace) do
+      flags = ConfigReader.extract_flags "config.json"
+      compiler_name = flags["compiler"] ? flags["compiler"] : "clang++"
+      abort_on_err "compiler #{compiler_name} not found" unless File.exists?("/usr/bin/#{compiler_name}")
+      compiler_flags = ["-Isrc/components"]
+      linker_flags = []
+
+      c_flags, l_flags = flags["flags"]["compile"], flags["flags"]["link"]
+      build_flags(compiler_flags, c_flags)
+      build_flags(linker_flags, l_flags)
+
+      @compiler = Compiler.new compiler_name, compiler_flags, linker_flags
+    end
+  end
+
+  def compile(f, o)
+    @compiler.compile f, o
+  end
+
+  def link_exectutable(odir, objs)
+    puts "#{"[100%]".green} linking"
+    @compiler.link_executable "#{odir}/#{@name}", objs
+  end
+
+  def link_shared(odir, objs)
+    puts "#{"[100%]".green} linking"
+    @compiler.link_shared "#{odir}/lib#{@name}", objs
+  end
+
+  def build_bin(files)
+    # return if files.empty?
+    build_compiler_from_config
+    if build_common(files) && link_exectutable("./target", Dir.glob("obj/*.o"))
+      puts "BUILDING SUCCEEDED".green
+    else
+      puts "building FAILED".red
+    end
+  end
+
+  def build_lib(files)
+    # return if files.empty?
+    build_compiler_from_config
+    @compiler.append_compiling_flag "-fPIC"
+    if build_common(files) && link_shared("./target", Dir.glob("obj/*.o"))
+      puts "BUILDING SUCCEEDED".green
+    else
+      puts "building FAILED".red
+    end
+  end
+
+  def build_common(files)
+    all = SourceFiles.get_all("./src") { |f| f.end_with? @source_suffix }
+    total = all.size.to_f
+    compiled = total - files.size
+    comps = files.select { |f| f.start_with? @components_prefix }
+    srcs = files - comps
+    flag = true
+
+    srcs.each do |f|
+      progress = (compiled / total).round(2) * 100
+      printf "[#{progress.to_i}%%]".green + " compiling #{f}: "
+      fname = f.split("/")[-1]
+      o = @obj_prefix + File.basename(fname, ".*") + ".o"
+      flag = false unless compile f, o
+      compiled += 1
+    end
+
+    comps.each do |f|
+      progress = (compiled / total).round(2) * 100
+      printf "[#{progress.to_i}%%]".green + " compiling #{f}: "
+      o = @obj_prefix + f.delete_suffix(File.extname(f))[@components_prefix.length..]
+        .gsub("/", "_") + ".o"
+      flag = false unless compile f, o
+      compiled += 1
+    end
+    flag
+  end
+
+  def build_all
+    build_target
+    build_test
+  end
+
+  def build_target
+    deps = File.exist?(@deps) ?
+      DepAnalyzer.read_from(@deps) :
+      DepAnalyzer.new("./src").build_to_file(["./src", "./src/components"], @deps)
+    target = "./target/#{@name}"
+    build_time = File.exist?(target) ? File.mtime(target) : Time.new(0)
+    files = DepAnalyzer.compiling_filter(deps, build_time, @source_suffix, @header_suffix)
+
+    if files.empty? && File.exist?(target)
+      puts "nothing to do, all up to date"
+      return
+    end
+
+    self.send "build_#{@mode.to_s}", files
+  end
+end

data/lib/workspace/clean.rb

@@ -0,0 +1,27 @@
+class WorkSpace
+  def clean
+    self.send "clean_#{@mode.to_s}"
+  end
+
+  private
+
+  def clean_obj
+    puts "rm -f ./obj/*.o"
+    system "rm -f ./obj/*.o"
+  end
+
+  def clean_target
+    puts "rm -f ./target/*"
+    system "rm -f ./target/*"
+  end
+
+  def clean_bin
+    clean_obj
+    clean_target
+  end
+
+  def clean_lib
+    clean_obj
+    clean_target
+  end
+end

data/lib/workspace/dep.rb

@@ -0,0 +1,12 @@
+class WorkSpace
+  def dep
+    deps = DepAnalyzer.read_from(@deps) if File.exist?(@deps)
+    deps.each do |k, v|
+      unless v.empty?
+        puts "#{k.blue} depends on: "
+        v.each { |f| puts "    #{f.blue}" }
+        puts ""
+      end
+    end
+  end
+end

data/lib/workspace/generate.rb

@@ -0,0 +1,5 @@
+class WorkSpace
+  def generate
+    DepAnalyzer.new("./src", @source_suffix, @header_suffix).build_to_file ["./src", "./src/components"], @deps
+  end
+end

data/lib/workspace/help.rb

@@ -0,0 +1,76 @@
+class WorkSpace
+  def self.help
+    info = <<~INFO
+      canoe is a C/C++ project manager, inspired by Rust cargo.
+      usage:
+          canoe new tada: create a project named 'tada' in current directory
+            
+          canoe build: compile current project (execute this command in project directory)
+      
+          canoe generate: generate dependency relationships and store it in '.canoe.deps' file. Alias: update
+
+          canoe update: udpate dependency relationships and store it in '.canoe.deps' file. 
+              
+          canoe run: compile and execute current project (execute this command in project directory)
+            
+          canoe clean: remove all generated object files and binary files
+            
+          canoe help: show this help message
+      
+          canoe add tada: add a folder named tada under workspace/components,
+            
+          canoe dep: show current dependency relationships of current project
+            
+          canoe verion: version information
+
+          canoe make: generate a makefile for this project
+      
+      new project_name [mode] [suffixes]:
+          create a new project with project_name.
+          In this project, four directories obj, src, target and third-party will be generated in project directory.
+          in src, directory 'components' will be generated if [mode] is '--lib', an extra main.cpp will be generated if [mode] is '--bin'
+      
+          [mode]: --lib for a library and --bin for executable binaries
+          [suffixes]: should be in 'source_suffix:header_suffix" format, notice the ':' between two suffixes
+      add component_name:
+          add a folder named tada under workspace/components.
+          two files tada.hpp and tada.cpp would be craeted and intialized. File suffix may differ according users' specifications.
+          if component_name is a path separated by '/', then canoe would create folders and corresponding files recursively.
+      
+      generate: 
+          generate dependence relationship for each file, this may accelarate
+          `canoe buid` command. It's recommanded to execute this command everytime
+          headers are added or removed from any file.
+          
+      update:
+          this command is needed because '.canoe.deps' is actually a cache of dependency relationships so that canoe doesn't have to analyze all the files when building a project.
+          So when a file includes new headers or some headers are removed, users have to use 'canoe udpate'
+          to update dependency relationships.
+      
+      build [options]:
+          build current project, arguments in [options] will be passed to C++ compiler
+        
+      run [options]:
+          build current project with no specific compilation flags, and run this project, passing [options] as command line arguments to the binary
+      
+      clean:
+          remove all generated object files and binary files
+      
+      help:
+          show this help message
+      
+      verion: 
+          display version information
+      
+      dep:
+          display file dependencies in a better readable way
+
+      make: 
+          generate a Makefile for this project
+      
+      @author: written by XIONG Ziwei, ICT, CAS
+      @contact: noahxiong@outlook.com
+    INFO
+    puts info
+  end
+end

data/lib/workspace/make.rb

@@ -0,0 +1,232 @@
+class Makefile
+  def initialize(workspace)
+    @workspace = workspace
+    @all_names = []
+    @common_variables = {}
+    @src_variables = {}
+    @hdr_variables = {}
+    @obj_variables = {}
+    @config = {}
+  end
+
+  def configure(config)
+    @config = config
+  end
+
+  def make!(deps)
+    File.open("Makefile", "w") do |f|
+      if cxx?(get_compiler)
+        make_cxx(f, deps)
+      else
+        make_c(f, deps)
+      end
+    end
+  end
+
+  private
+
+  def get_compiler
+    @config["compiler"]
+  end
+
+  def get_header_suffix
+    @workspace.header_suffix
+  end
+
+  def get_source_suffix
+    @workspace.source_suffix
+  end
+
+  def get_compiling_flags
+    flags = @config["flags"]["compile"].values.join " "
+    flags + " -I./src/components"
+  end
+
+  def get_ldflags
+    @config["flags"]["link"].values.select { |v| v.start_with?("-L") }.join " "
+  end
+
+  def get_ldlibs
+    (@config["flags"]["link"].values - (get_ldflags.split)).join " "
+  end
+
+  def cxx?(name)
+    return get_compiler.end_with? "++"
+  end
+
+  def make_cxx(makefile, deps)
+    make_common(makefile, "CXX", deps)
+  end
+
+  def make_c(makefile, deps)
+    make_common(makefile, "CC", deps)
+  end
+
+  def make_common(makefile, compiler_prefix, deps)
+    make_compiling_info(makefile, compiler_prefix)
+    define_variables(makefile, deps)
+    make_rules(makefile, deps)
+  end
+
+  def make_compiling_info(makefile, compiler_prefix)
+    makefile.puts("#{compiler_prefix}=#{get_compiler}")
+    makefile.puts("#{compiler_prefix}FLAGS=#{get_compiling_flags}")
+    makefile.puts("LDFLAGS=#{get_ldflags}")
+    makefile.puts("LDLIBS=#{get_ldlibs}")
+    makefile.puts ""
+  end
+
+  def define_variables(makefile, deps)
+    define_dirs(makefile)
+
+    src_files = deps.keys.select { |f| f.end_with? get_source_suffix }
+    generate_all_names(src_files)
+    define_srcs(makefile, src_files)
+    makefile.puts ""
+    define_hdrs(makefile, src_files)
+    makefile.puts ""
+    define_objs(makefile, src_files)
+    makefile.puts ""
+  end
+
+  def extract_name(name, prefix)
+    if name.start_with?(prefix)
+      name.delete_suffix(File.extname(name))[prefix.length..].gsub("/", "_")
+    else
+      File.basename(name.split("/")[-1], ".*")
+    end
+  end
+
+  def generate_all_names(files)
+    files.each do |f|
+      name = extract_name(f, @workspace.components_prefix).upcase
+      @all_names << name
+      @src_variables[name] = f
+      @hdr_variables[name] = f.gsub(@workspace.source_suffix, @workspace.header_suffix)
+      @obj_variables[name] = @workspace.obj_prefix + extract_name(f, @workspace.components_prefix) + ".o"
+    end
+  end
+
+  def define_dirs(makefile)
+    makefile.puts("TARGET_DIR=./target")
+    if @workspace.mode == :bin
+      makefile.puts("TARGET=$(TARGET_DIR)/#{@workspace.name}")
+    else
+      makefile.puts("TARGET=$(TARGET_DIR)/lib#{@workspace.name.downcase}.so")
+    end
+    # note the ending slash
+    makefile.puts("OBJ_DIR=#{@workspace.obj_prefix[..-2]}")
+    makefile.puts("SRC_DIR=#{@workspace.src_prefix[..-2]}")
+    makefile.puts("COMPONENTS_DIR=#{@workspace.components_prefix[..-2]}")
+    makefile.puts ""
+  end
+
+  def define_srcs(makefile, files)
+    @src_variables.each do |k, v|
+      makefile.puts("SRC_#{k}=#{v}")
+    end
+  end
+
+  def define_hdrs(makefile, files)
+    @hdr_variables.each do |k, v|
+      next if k == "MAIN"
+      makefile.puts("HDR_#{k}=#{v}")
+    end
+  end
+
+  def define_objs(makefile, files)
+    @obj_variables.each do |k, v|
+      makefile.puts("OBJ_#{k}=#{v}")
+    end
+    objs = @obj_variables.keys.map { |k| "$(OBJ_#{k})" }.join " "
+    makefile.puts("OBJS=#{objs}")
+    makefile.puts ""
+  end
+
+  def get_all_dep_name(file_name, deps)
+    dep = deps[file_name]
+    if dep.empty?
+      []
+    else
+      tmp = dep.map { |n| extract_name(n, @workspace.components_prefix).upcase }
+      dep.each do |d|
+        tmp += get_all_dep_name(d, deps)
+      end
+      tmp
+    end
+  end
+
+  def emit_dependencies(makefile, name, deps)
+    as_str = deps.map do |n|
+      if n == name
+        ["$(SRC_#{n})"] + ["$(HDR_#{n})"] * (name == "MAIN" ? 0 : 1)
+      else
+        "$(#{n}_DEP)"
+      end
+    end.flatten.join " "
+    makefile.puts("#{name}_DEP=#{as_str}")
+  end
+
+  def make_dependencies(makefile, deps)
+    dep_variables = Hash[@all_names.map { |n| [n, []] }]
+    reference = Hash[@all_names.map { |n| [n, []] }]
+    @all_names.each do |n|
+      dep_variables[n] = ([n] + get_all_dep_name(@src_variables[n], deps)).uniq
+      reference[n] = ([n] + get_all_dep_name(@src_variables[n], deps)).uniq
+    end
+
+    # deduplication
+    dep_variables.each do |k, v|
+      v.each do |n|
+        next if n == k
+        v = v - reference[n] + [n] if v.include? n
+      end
+      dep_variables[k] = v
+    end
+
+    dep_variables.each do |k, v|
+      emit_dependencies(makefile, k, v)
+    end
+  end
+
+  def make_rules(makefile, deps)
+    make_dependencies(makefile, deps)
+    makefile.puts ""
+    makefile.puts("all: BIN\n")
+    makefile.puts ""
+    cmplr = cxx?(get_compiler) ? "CXX" : "CC"
+    @all_names.each do |n|
+      makefile.puts("$(OBJ_#{n}): $(#{n}_DEP)\n\t$(#{cmplr}) $(#{cmplr}FLAGS) -o $(OBJ_#{n}) -c $(SRC_#{n})")
+      makefile.puts ""
+    end
+
+    if @workspace.mode == :bin
+      makefile.puts("BIN: $(OBJS)\n\t$(#{cmplr}) $(#{cmplr}FLAGS) -o $(TARGET) $(wildcard ./obj/*.o) $(LDFLAGS) $(LDLIBS)")
+    else
+      makefile.puts("LIB: $(OBJS)\n\t$(#{cmplr}) $(#{cmplr}FLAGS) -shared -o $(TARGET) $(wildcard ./obj/*.o) -fPIC $(LDFLAGS) $(LDLIBS)")
+    end
+    makefile.puts ""
+
+    clean = <<~DOC
+      .PHONY: clean
+      clean: 
+      \trm $(TARGET)
+      \trm ./obj/*.o
+    DOC
+    makefile.puts(clean)
+  end
+end
+
+class WorkSpace
+  def make
+    config = ConfigReader.extract_flags "config.json"
+
+    deps = File.exist?(@deps) ?
+      DepAnalyzer.read_from(@deps) :
+      DepAnalyzer.new("./src").build_to_fil
+
+    makefile = Makefile.new(self)
+    makefile.configure(config)
+    makefile.make!(deps)
+  end
+end