canoe 0.3.0 → 0.3.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,120 +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 = {}
-    deps.keys.each do |k|
-      @processed[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
-        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
-          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)
-    return false unless File.exists? file
-    if should_recompile?(file, build_time)
-      return true
-    else
-      deps[file].each do |f|
-        next if @processed[f]
-        @processed[f] = true
-        return true if mark(f, build_time, deps)
+      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
+        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
-    false
-  end
 
-  def self.should_recompile?(file, build_time) 
-    judge = build_time
-    if build_time == Time.new(0)
-      objfile = "./obj/#{File.basename(file, ".*")}.o"
-      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,81 @@
+require_relative 'coloring'
+
+module Canoe
+  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 get_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)
+      get_current_workspace.src_to_obj(src)
+    end
+
+    def comp_to_obj(comp)
+      get_current_workspace.comp_to_obj(comp)
+    end
+
+    def file_to_obj(file)
+      get_current_workspace.file_to_obj(file)
+    end
+
+    def extract_one_file(file, deps)
+      get_current_workspace.extract_one_file(file, deps)
+    end
+
+    def extract_one_file_obj(file, deps)
+      get_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

@@ -0,0 +1,29 @@
+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}"
+            create_working_files prefix.join('__'), filename
+          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
+end

data/lib/workspace/build.rb

@@ -0,0 +1,150 @@
+module Canoe
+  class WorkSpace
+    def src_to_obj(src)
+      @obj_prefix + File.basename(src, ".*") + ".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
+        src_to_obj file
+      end
+    end
+
+    # args are commandline parameters passed to `canoe build`,
+    # could be 'all', 'test', 'target' or empty
+    def build(args)
+      options = {[] => 'target', ['all'] => 'all', ['test'] => 'test'}
+      if options.include?(args)
+        send "build_#{options[args]}"
+      else
+        abort_on_err "Unkown subcommand #{args.join(" ").red}"
+      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
+      flags = ConfigReader.extract_flags "config.json"
+      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"]
+      build_flags(compiler_flags, c_flags)
+      build_flags(linker_flags, l_flags)
+
+      @compiler = Compiler.new compiler_name, compiler_flags, linker_flags
+    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)
+      if build_common(files) &&
+         link_exectutable(@target_short, Dir.glob("obj/*.o").reject { |f| f.start_with? 'obj/test_' })
+        puts "BUILDING SUCCEEDED".green
+        return true
+      else
+        puts "building target FAILED".red
+        return false
+      end
+    end
+
+    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
+
+    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
+
+      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}..."
+      deps = get_deps @deps, @src, [@src_short, @components_short]
+      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 
+
+      build_compiler_from_config
+
+      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
+end