canoe 0.3.0.2 → 0.3.2.2

data/lib/dependence.rb

@@ -1,11 +1,10 @@
 require_relative 'source_files'
-require_relative 'err'
-
+require_relative 'util'
 ##
 # class DepAnalyzer
-#   This class is the key component of canoe, which offers file dependency analysis functionality. 
+#   This class is the key component of canoe, which offers file dependency analysis functionality.
 #     A DepAnalyzer takes a directory as input, sources files and corresponding header files in this
-#     directory should have same name, i.e. test.cpp and test.hpp.
+#     directory should have same name, e.g. test.cpp and test.hpp.
 #     DepAnalyzer would read every source file and recursively process user header files included in this source file to
 #     find out all user header files this source file depends on.
 #     Based on dependencies built in previous stage, DepAnalyzer determines which files should be recompiled and return
@@ -14,136 +13,140 @@ require_relative 'err'
 #     Dependencies could be written to a file to avoid wasting time parsing all files, Depanalyzer would read from
 #     this file to construct dependencies. But if sources files included new headers or included headers are revmoed,
 #     Depanalyzer should rebuild the whole dependencies.
-class DepAnalyzer
-  include Err
-  def self.read_from(filename)
-    File.open(filename, "r") do |f|
-      ret = Hash.new []
-      f.each_with_index do |line, i|
-        entry = line.split(': ')
-        Err.abort_on_err("Bad .canoe.deps format, line #{i+1}") unless entry.length == 2
-        ret[entry[0]] = entry[1].split
-      end            
-      ret
-    end
-  end
+module Canoe
+  class DepAnalyzer
+    include Err
+    include SystemCommand
 
-  def self.compiling_filter(deps, build_time, src_sfx='cpp', hdr_sfx='hpp')
-    files = []
-    @processed = {}
-    @recompiles = {}
-    deps.keys.each do |k|
-      @processed[k] = false
-      @recompiles[k] = false
-    end
-    deps.each do |k, v|
-      next if k.end_with? ".#{hdr_sfx}"
-      if should_recompile?(k, build_time)
-        files << k
-        @processed[k] = true
-        @recompiles[k] = true
-        next
+    class << self
+      include WorkSpaceUtil
+      def read_from(filename)
+        File.open(filename, 'r') do |f|
+          ret = Hash.new []
+          f.each_with_index do |line, i|
+            entry = line.split(': ')
+            abort_on_err("Bad .canoe.deps format, line #{i + 1}") unless entry.length == 2
+            ret[entry[0]] = entry[1].split
+          end
+          ret
+        end
       end
-      v.each do |f|
-        if mark(f, build_time, deps) || mark(f.sub(".#{hdr_sfx}", ".#{src_sfx}"), build_time, deps)
-          files << k
-          @processed[k] = true
-          @recompiles[k] = true
-          break
+
+      def compiling_filter(deps, build_time, src_sfx = 'cpp', hdr_sfx = 'hpp')
+        files = []
+        @processed = {}
+        @recompiles = {}
+        deps.each_key do |k|
+          @processed[k] = false
+          @recompiles[k] = false
+        end
+        deps.each do |k, v|
+          next if k.end_with? ".#{hdr_sfx}"
+
+          if should_recompile?(k, build_time)
+            files << k
+            @processed[k] = true
+            @recompiles[k] = true
+            next
+          end
+          v.each do |f|
+            next unless mark(f, build_time, deps) || mark(f.sub(".#{hdr_sfx}", ".#{src_sfx}"), build_time, deps)
+
+            files << k
+            @processed[k] = true
+            @recompiles[k] = true
+            break
+          end
         end
+        files
       end
-    end
-    files
-  end
 
-  private
-  def self.mark(file, build_time, deps)
-    ret = false
-    return false unless File.exists? file
-    if should_recompile?(file, build_time)
-      return true
-    else
-      deps[file].each do |f|
-        if @processed[f]
-          ret |= @recompiles[f]
-          next
+      private
+
+      def mark(file, build_time, deps)
+        ret = false
+        return false unless File.exist? file
+        return true if should_recompile?(file, build_time)
+
+        deps[file].each do |f|
+          if @processed[f]
+            ret |= @recompiles[f]
+            next
+          end
+          @processed[f] = true
+          if mark(f, build_time, deps)
+            @recompiles[f] = true
+            return true
+          end
         end
-        @processed[f] = true
-        if mark(f, build_time, deps)
-          @recompiles[f] = true
-          return true 
+        ret
+      end
+
+      def should_recompile?(file, build_time)
+        judge = build_time
+        if build_time == Time.new(0)
+          objfile = file_to_obj(file)
+          return true unless File.exist? objfile
+
+          judge = File.mtime(objfile)
         end
+        File.mtime(file) > judge
       end
     end
-    ret
-  end
 
-  def self.should_recompile?(file, build_time) 
-    judge = build_time
-    if build_time == Time.new(0)
-      objfile = if file.start_with?("./src/components")
-                  './obj/' + file.delete_suffix(File.extname(file))['./src/components/'.length..].gsub('/', '_') + '.o'
-                else
-                  "./obj/#{File.basename(file, ".*")}.o"
-                end
-      return true unless File.exists? objfile
-      judge = File.mtime(objfile)
+    def initialize(dir, src_sfx = 'cpp', hdr_sfx = 'hpp')
+      @dir = dir
+      @deps = Hash.new []
+      @source_suffix = src_sfx
+      @header_suffix = hdr_sfx
     end
-    File.mtime(file) > judge
-  end
 
-  public
-  def initialize(dir, src_sfx='cpp', hdr_sfx='hpp')
-    @dir = dir
-    @deps = Hash.new []
-    @source_suffix = src_sfx
-    @header_suffix = hdr_sfx
-  end
+    def build_dependence(include_path)
+      files = SourceFiles.get_all(@dir) do |f|
+        f.end_with?(".#{@source_suffix}") || f.end_with?(".#{@header_suffix}")
+      end
 
-  def build_dependence(include_path)
-    files = SourceFiles.get_all(@dir) do |f|
-      f.end_with?(".#{@source_suffix}") || f.end_with?(".#{@header_suffix}")
-    end
+      @deps = Hash.new []
+      files.each do |fname|
+        @deps[fname] = get_all_headers include_path, fname, @header_suffix
+      end
 
-    @deps = Hash.new []
-    files.each do |fname|
-      @deps[fname] = get_all_headers include_path, fname, @header_suffix
+      @deps
     end
 
-    @deps
-  end
+    def build_to_file(include_path, filename)
+      build_dependence include_path
 
-  def build_to_file(include_path, filename)
-    build_dependence include_path
-    
-    File.open(filename, "w") do |f|
-      @deps.each do |k, v|
-        f.write "#{k}: #{v.join(" ")}\n"
+      File.open(filename, 'w') do |f|
+        @deps.each do |k, v|
+          f.write "#{k}: #{v.join(' ')}\n"
+        end
       end
+
+      @deps
     end
-    
-    @deps
-  end
 
-  private
-  def get_all_headers(include_path, file, suffix='hpp')
-    File.open(file, "r") do |f|
-      ret = []
-      if file.end_with?(".#{@source_suffix}")
-        header = file.sub(".#{@source_suffix}", ".#{@header_suffix}")
-        ret += [header] if File.exists?(header)
-      end
-      
-      f.each_line do |line|
-        if mat = line.match(/include "(.+\.#{suffix})"/)
-          include_path.each do |path|
-            dep = "#{path}/#{mat[1]}"
-            ret += [dep] if File.exists? dep
+    private
+
+    def get_all_headers(include_path, file, suffix = 'hpp')
+      File.open(file, 'r') do |f|
+        ret = []
+        if file.end_with?(".#{@source_suffix}")
+          header = file.sub(".#{@source_suffix}", ".#{@header_suffix}")
+          ret += [header] if File.exist?(header)
+        end
+
+        f.each_line do |line|
+          if (mat = line.match(/include "(.+\.#{suffix})"/))
+            include_path.each do |path|
+              dep = "#{path}/#{mat[1]}"
+              ret += [dep] if File.exist? dep
+            end
           end
         end
+
+        ret.uniq
       end
-      
-      ret.uniq
     end
   end
 end

data/lib/source_files.rb

@@ -5,27 +5,28 @@ class SourceFiles
   class << self
     def get_all(dir, &block)
       @files = []
-      get_all_helper(dir, &block) 
+      get_all_helper(dir, &block)
       @files
     end
 
-    def get_in(dir, &block)
+    def get_in(dir)
       @files = []
       Dir.each_child(dir) do |f|
         file = "#{dir}/#{f}"
         if File.file? file
           if block_given?
-            @files << "#{file}" if yield(f)
+            @files << file.to_s if yield(f)
           else
-            @files << "#{file}"
+            @files << file.to_s
           end
-        end 
+        end
       end
-      
+
       @files
     end
 
     private
+
     def get_all_helper(dir, &block)
       Dir.each_child(dir) do |f|
         file = "#{dir}/#{f}"
@@ -42,4 +43,3 @@ class SourceFiles
     end
   end
 end
-

data/lib/util.rb

@@ -0,0 +1,84 @@
+require_relative 'coloring'
+
+module Canoe
+  ##
+  # Stepper record the progress of a task
+  # progress is obtained via #'progress_as_str
+  class Stepper
+    def initialize(total, togo)
+      @total = total.to_f
+      @togo = togo.to_f
+    end
+
+    def progress_as_str
+      progress = ((@total - @togo) / @total).round(2) * 100
+      "[#{progress.to_i}%%]"
+    end
+
+    def step
+      @togo -= 1 if @togo.positive?
+    end
+  end
+
+  ##
+  # wrapping workspace related functionality to expose to other modules
+  module WorkSpaceUtil
+    def current_workspace
+      abort_on_err 'not in a canoe workspace' unless File.exist? '.canoe'
+      config = ConfigReader.extract_flags('config.json')
+
+      src_sfx = config['source-suffix'] || 'cpp'
+      hdr_sfx = config['header-suffix'] || 'hpp'
+
+      name = Dir.pwd.split('/')[-1]
+      mode = File.exist?("src/main.#{src_sfx}") ? :bin : :lib
+
+      WorkSpace.new(name, mode, src_sfx, hdr_sfx)
+    end
+
+    def src_to_obj(src)
+      current_workspace.src_to_obj(src)
+    end
+
+    def comp_to_obj(comp)
+      current_workspace.comp_to_obj(comp)
+    end
+
+    def file_to_obj(file)
+      current_workspace.file_to_obj(file)
+    end
+
+    def extract_one_file(file, deps)
+      current_workspace.extract_one_file(file, deps)
+    end
+
+    def extract_one_file_obj(file, deps)
+      current_workspace.extract_one_file_obj(file, deps)
+    end
+  end
+
+  module SystemCommand
+    def issue_command(cmd_str)
+      puts cmd_str
+      system cmd_str
+    end
+  end
+  
+  module Err
+    def warn_on_err(err)
+      puts <<~ERR
+           #{'Waring: '.yellow}
+               #{err}
+           try 'canoe help' for more information
+         ERR
+    end
+
+    def abort_on_err(err)
+      abort <<~ERR
+            #{'Fatal: '.red}
+                #{err}
+            try 'canoe help' for more information
+          ERR
+    end
+  end
+end

data/lib/workspace/add.rb

@@ -1,26 +1,29 @@
-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 
+module Canoe
+  class WorkSpace
+    def add(args)
+      args.each do |i|
+        dir = @components
+        filenames = i.split '/'
+        prefix = []
+        filenames.each do |filename|
+          dir += "/#{filename}"
+          prefix << filename
+          next if Dir.exist? dir
+
+          FileUtils.mkdir dir
           Dir.chdir(dir) do
-            puts "created " + Dir.pwd.blue
+            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
+    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
-end
+end

data/lib/workspace/build.rb

@@ -1,130 +1,190 @@
-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
+require 'json'
+module Canoe
+  class WorkSpace
+    def src_to_obj(src)
+      @obj_prefix + File.basename(src, ".*") + ".o"
     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
+    def comp_to_obj(comp)
+      @obj_prefix + comp.delete_suffix(File.extname(comp))[@components_prefix.length..].gsub("/", "_") + ".o"
+    end
+
+    # the if else order is important because tests are regarded as sources
+    def file_to_obj(file)
+      if file.start_with?(@components_prefix)
+        comp_to_obj file
       else
-        abort_on_err "unknown options in config.json, #{v}"
+        src_to_obj file
       end
     end
-  end
 
-  def build_compiler_from_config
-    Dir.chdir(@workspace) do
+    # args are commandline parameters passed to `canoe build`,
+    # could be 'all', 'test', 'target', 'base' or empty
+    def build(arg = 'target')
+      send "build_#{arg}"
+    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
       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']
+      compiler_name = flags["compiler"] ? flags["compiler"] : "clang++"
+
+      abort_on_err "compiler #{compiler_name} not found" unless system "which #{compiler_name} > /dev/null"
+      compiler_flags = ["-Isrc/components"]
       linker_flags = []
 
-      c_flags, l_flags = flags['flags']['compile'], flags['flags']['link']
+      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 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_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 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"))
+    def build_bin(files)
+      if build_common(files) &&
+         link_exectutable(@target_short, Dir.glob("obj/*.o").reject { |f| f.start_with? 'obj/test_' })
         puts "BUILDING SUCCEEDED".green
-    else 
-      puts "building FAILED".red
+        return true
+      else
+        puts "building target FAILED".red
+        return false
+      end
     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
+    def build_lib(files)
+      @compiler.append_compiling_flag "-fPIC"
+      if build_common(files) &&
+         link_shared(@target_short, Dir.glob("obj/*.o").reject { |f| f.start_with? 'obj/test_'})
+        puts "BUILDING SUCCEEDED".green
+      else
+        puts "building target FAILED".red
+      end
     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_common(files)
+      all = SourceFiles.get_all(@src_short) { |f| f.end_with? @source_suffix }
+      stepper = Stepper.new all.size, files.size
+      flag = true
 
-  def build_all
-    build_target
-    build_test
+      files.each do |f|
+        progress = stepper.progress_as_str.green
+        printf "#{progress.green} compiling #{f.yellow}: "
+        o = file_to_obj(f)
+        flag = false unless compile f, o
+        stepper.step
+      end
+      flag
+    end
+
+    def build_all
+      build_target
+      build_test
+    end
+
+    def get_deps(dep_file, source_dir, include_dirs)
+      File.exist?(dep_file) ? DepAnalyzer.read_from(dep_file) :
+        DepAnalyzer.new(source_dir, @source_suffix, @header_suffix).build_to_file(include_dirs, dep_file)
+    end
+
+    def target_deps
+      get_deps @deps, @src_short, [@src_short, @components_short]
+    end
+
+    # contain only headers
+    # sources in ./src/components are not included
+    def tests_deps
+      get_deps @test_deps, @tests_short, [@src_short, @components_short]
+    end
+
+    def build_target
+      puts "#{'[BUILDING TARGET]'.magenta}..."
+      target = "#{@target}/#{@name}"
+      build_time = File.exist?(target) ? File.mtime(target) : Time.new(0)
+      files = DepAnalyzer.compiling_filter target_deps, build_time, @source_suffix, @header_suffix 
+
+      build_compiler_from_config
+
+      if files.empty? && File.exist?(target)
+        puts "nothing to do, all up to date"
+        return true
+      end
+
+      self.send "build_#{@mode.to_s}", files
+    end
+
+    # generate a compile_commands.json file
+    def build_base
+      deps = target_deps.merge tests_deps
+      build_compiler_from_config
+      database = CompilationDatabase.new
+      deps.each_key do |k|
+        next if k.end_with? @header_suffix
+        c = @compiler.name.end_with?('++') ? 'c++' : 'c'
+
+        arg =  [c] + @compiler.compiling_flags_as_str.split + [k] + [file_to_obj(k)] + ['-c', '-o']
+        database.add_command_object(@workspace, arg, k)
+      end
+      File.open('compile_commands.json', 'w') do |f|
+        f.puts database.pretty_to_s
+      end
+    end
   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)
+  class CompilationDatabase
+    attr_reader :database
+    def initialize
+      @database = []
+    end
+
+    def add_command_object(dir, arguments, file)
+      temp = {             
+        "arguments" => arguments,
+        "directory" => dir,
+        "file" => file
+      }
+      @database << temp
+    end
 
-    if files.empty? && File.exist?(target)
-      puts "nothing to do, all up to date"
-      return
+    def to_s
+      @database.to_s
     end
 
-    self.send "build_#{@mode.to_s}", files
+    def pretty_to_s
+      JSON.pretty_generate(@database)
+    end
+
+    def to_json
+      @database.to_json
+    end
   end
-end
+end