canoe 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 78d6318d9757575b6e8f3f118e161ca06bb08655f26e7531e33c31d63f26aa18
+  data.tar.gz: 5cb8230a80e4bb2f03b8afb3dbebea90fccfd4b97bafa652502b2161e70ce374
+SHA512:
+  metadata.gz: 9501ebdd1d4ef09e6bfaede0c712044d665650b2a9d07dcfe490fe35afc378dae1d66429dc5919e217b48f4d3df9156611a4c496c64ebe3916870fc2da48453a
+  data.tar.gz: 848272aacd562ef7bc05ae50bd948a4221721b9432be46acb669e8ee6bb4f5a27e7e7ed57d5e6b64d83fce52be6a882955324f0c782b9e9252611ed29ba50cf8

data/bin/canoe

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'canoe'
+
+Canoe.new.parse ARGV

data/lib/canoe.rb

@@ -0,0 +1,14 @@
+require_relative "workspace"
+require_relative "cmd"
+require_relative "source_files"
+
+class Canoe
+  def initialize
+    options = ["new", "build", "run", "clean", "help", "add", "generate", "deps", "version"]
+    @cmd = CmdParser.new options
+  end
+
+  def parse(args)
+      @cmd.parse args
+  end
+end

data/lib/cmd.rb

@@ -0,0 +1,107 @@
+require_relative "workspace"
+require_relative "err"
+require_relative "config_reader"
+
+class CmdParser
+  include Err
+  def initialize(options)
+    @options = options 
+  end
+
+  def parse(args)
+    if args.size < 1 
+      abort_on_err "please give one command among #{@options.join(', ')}"
+    end
+
+    unless @options.include?(args[0])
+      abort_on_err "unknown command #{args[0]}"
+    end
+
+    self.send "parse_#{args[0]}", args[1..]
+  end
+
+  private
+  def get_current_workspace
+    abort_on_err "not in a canoe workspace" unless File.exists? ".canoe"
+    config = ConfigReader.extract_flags("config.json")
+
+    src_sfx = config["source-suffix"] ? config["source-suffix"] : "cpp"
+    hdr_sfx = config["header-suffix"] ? config["header-suffix"] : "hpp"
+
+    name = Dir.pwd.split("/")[-1]
+    mode = File.exists?("src/main.#{src_sfx}") ? :bin : :lib
+
+    Dir.chdir('..') do
+      return WorkSpace.new(name, mode, src_sfx, hdr_sfx)
+    end
+  end
+
+  def parse_new(args)
+    abort_on_err "not enough arguments to canoe new" if args.size < 1
+
+    name, mode = nil, "bin"
+    suffixes = ["cpp", "hpp"]
+    
+    args.each do |arg|
+      case arg
+      when '--bin', '--lib'
+        mode = arg[2..]
+      when /--suffix=(\w+)\:(\w+)/
+        suffixes[0], suffixes[1] = $1, $2
+      else
+        name = arg unless name
+      end
+    end
+    
+    abort_on_err("please give a name to this project") unless name
+    WorkSpace.new(name, mode.to_sym, suffixes[0], suffixes[1]).new
+  end
+
+  def parse_add(args)
+    if args.size < 1
+      abort_on_err "it's not reasonable to add a component with no name given"
+    end
+
+    get_current_workspace.add args
+  end
+  
+  def parse_build(args)
+    get_current_workspace.build args
+  end
+
+  def parse_generate(args)
+    get_current_workspace.generate
+  end
+  
+  def parse_run(args)
+    get_current_workspace.run args
+  end
+
+  def parse_dep(args)
+    get_current_workspace.dep 
+  end
+  
+  def parse_clean(args)
+    get_current_workspace.clean
+  end
+
+  def parse_version(args)
+    puts <<~VER
+        canoe v0.2.1
+        For features in this version, please visit https://github.com/Dicridon/canoe
+        Currently, canoe can do below:
+            - project creation
+            - project auto build and run (works like Cargo for Rust)
+            - project structure management
+        by XIONG Ziwei
+        VER
+  end
+  
+  def parse_help(args)
+    WorkSpace.help
+  end
+
+  def parse_update(args)
+    get_current_workspace.update
+  end
+end

data/lib/compiler.rb

@@ -0,0 +1,31 @@
+class Compiler
+  attr_reader :name, :flags
+  def initialize(name, flgs)
+    @name = name
+    @flags = flgs
+  end
+
+  def flags_as_str
+    flags.join " "
+  end
+
+  def append_flag(flag)
+    @flags << flag
+  end
+
+  def compile(src, out)
+    puts "#{name} -o #{out} #{flags_as_str} -c #{src}"
+    system "#{name} -o #{out} #{flags_as_str} -c #{src}"
+  end
+
+  def link(out, objs)
+    libs = flags.select {|f| f.start_with?('-l')}
+    puts "#{name} -o #{out} #{objs.join(" ")} #{libs.join(" ")}"
+    system "#{name} -o #{out} #{objs.join(" ")} #{libs.join(" ")}"
+  end
+
+  def inspect
+    puts "compiler name: #{name.inspect}"
+    puts "compiler flags: #{flags.inspect}"
+  end
+end

data/lib/config_reader.rb

@@ -0,0 +1,8 @@
+require 'json'
+
+class ConfigReader
+  def self.extract_flags(file)
+    abort_on_err("config file #{file} does not exsit") unless File.exists? file
+    JSON.parse(File.read(file))
+  end
+end

data/lib/default_files.rb

@@ -0,0 +1,70 @@
+class DefaultFiles
+  def self.open_file_and_write(filename, content)
+    File.open(filename, "w") {|f|
+      f.write(content)
+    }
+  end
+
+  def self.create_config(path, src_sfx='cpp', hdr_sfx='hpp')
+    open_file_and_write(
+      "#{path}/config.json", 
+      <<~CONFIG
+        {
+            "compiler": "clang++",
+            "header-suffix": "#{hdr_sfx}",
+            "source-suffix": "#{src_sfx}",
+            "flags": {
+                "opt": "-O2",
+                "debug": "-g",
+                "std": "-std=c++17"
+            }
+        }
+      CONFIG
+    )
+  end
+
+  def self.create_main(path, suffix='cpp')
+    open_file_and_write(
+      "#{path}/main.#{suffix}",
+      <<~DOC
+        #include <iostream>
+        int main(int argc, char *argv[]) {
+            std::cout << "hello world!" << std::endl;
+        }
+      DOC
+    )
+  end
+
+  def self.create_emacs_dir_local(path)
+    open_file_and_write(
+      "#{path}/.dir-locals.el",
+      <<~DOC
+        ((nil . ((company-clang-arguments . ("-I./src/components/"
+                                             "-I./components/"))))
+         (nil . ((company-c-headers-path-user . ("./src/components/"
+                                 "./components/")))))
+      DOC
+    )
+  end
+
+  def self.create_cpp(filename, src_sfx='cpp', hdr_sfx='hpp')
+    open_file_and_write(
+      "#{filename}.#{src_sfx}", 
+      <<~DOC
+                #include "#{filename}.#{hdr_sfx}"
+            DOC
+    )
+  end
+
+  def self.create_hpp(workspace, prefix, filename, hdr_sfx='hpp')
+    open_file_and_write(
+      "#{filename}.#{hdr_sfx}",
+      <<~DOC
+        #ifndef __#{workspace.upcase}__#{prefix.upcase}__#{filename.upcase}__
+        #define __#{workspace.upcase}__#{prefix.upcase}__#{filename.upcase}__
+
+        #endif
+      DOC
+    )
+  end
+end

data/lib/dependence.rb

@@ -0,0 +1,113 @@
+require_relative 'source_files'
+require_relative 'err'
+
+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
+
+  def self.compiling_filter(deps, build_time, src_sfx='cpp', hdr_sfx='hpp')
+    files = [] 
+    deps.each do |k, v|
+      next if k.end_with? ".#{hdr_sfx}"
+      if should_recompile?(k, build_time)
+        files << k
+        next
+      end
+      v.each do |f|
+        if mark(f, build_time, deps) || mark(f.sub(".#{hdr_sfx}", ".#{src_sfx}"), build_time, deps)
+          files << k
+          break
+        end
+      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|
+        return true if mark(f, build_time, deps)
+      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)
+    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
+
+    @deps = Hash.new []
+    files.each do |fname|
+      @deps[fname] = get_all_headers include_path, fname, @header_suffix
+    end
+
+    @deps
+  end
+
+  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"
+      end
+    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
+          end
+        end
+      end
+      
+      ret.uniq
+    end
+  end
+end

data/lib/err.rb

@@ -0,0 +1,19 @@
+module Err
+  def warn_on_err(err)
+    puts <<~ERR
+           Warning: 
+               #{err}
+           try 'canoe help' for more information
+         ERR
+  end
+
+  def abort_on_err(err)
+    abort <<~ERR
+            Fatal: 
+                #{err}
+            try 'canoe help' for more information
+         ERR
+  end
+
+  module_function :warn_on_err, :abort_on_err
+end

data/lib/source_files.rb

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

data/lib/workspace.rb

@@ -0,0 +1,272 @@
+require 'fileutils'
+require 'open3'
+require_relative 'source_files'
+require_relative 'compiler'
+require_relative 'config_reader'
+require_relative 'default_files'
+require_relative 'err'
+require_relative 'dependence'
+
+class WorkSpace
+  include Err
+  attr_reader :name, :cwd
+  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 relationship and store it in '.canoe.deps'
+                
+                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,
+                                two files tada.hpp and tada.cpp would be craeted and intialized
+                
+                canoe verion: version information
+
+            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
+
+            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.
+
+            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
+
+            @author: written by XIONG Ziwei, ICT, CAS
+            @contact: noahxiong@outlook.com
+        INFO
+    puts info
+  end
+
+
+  def initialize(name, mode, src_suffix='cpp', hdr_suffix='hpp')
+    @name = name
+    @compiler = Compiler.new 'clang++', '-Isrc/components'
+    @cwd = Dir.new(Dir.pwd)
+    @workspace = "#{Dir.pwd}/#{@name}"
+    @src = "#{@workspace}/src"
+    @components = "#{@src}/components"
+    @obj = "#{@workspace}/obj"
+    @third = "#{@workspace}/third-party"
+    @target = "#{@workspace}/target"
+    @mode = mode
+    @deps = '.canoe.deps'
+
+    @src_prefix = './src/'
+    @components_prefix = './src/components/'
+    @obj_prefix = './obj/'
+
+    @source_suffix = src_suffix
+    @header_suffix = hdr_suffix
+  end
+
+  def new
+    Dir.mkdir(@name)
+    Dir.mkdir(@src)
+    Dir.mkdir(@components)
+    Dir.mkdir("#{@workspace}/obj")
+    DefaultFiles.create_main(@src, @source_suffix) if @mode == :bin
+    File.new("#{@workspace}/.canoe", "w")
+    DefaultFiles.create_config @workspace, @source_suffix, @header_suffix
+    DefaultFiles.create_emacs_dir_local @workspace
+
+    Dir.mkdir(@third)
+    Dir.mkdir(@target)
+    puts "workspace #{@workspace} is created"
+  end
+
+  # args are commandline parameters passed to `canoe build`    
+  def build(args)
+    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?
+      puts "nothing to do, all up to date"
+      return
+    end
+    
+    self.send "build_#{@mode.to_s}", files, args 
+  end
+
+  def generate
+    DepAnalyzer.new('./src', @source_suffix, @header_suffix)
+               .build_to_file ['./src', './src/components'], @deps
+  end
+
+  def update
+    generate
+  end
+
+  def clean
+    self.send "clean_#{@mode.to_s}"
+  end
+
+  def run(args)
+    build []
+    args = args.join " "
+    puts "./target/#{@name} #{args}"
+    exec "./target/#{@name} #{args}"
+  end
+
+  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
+            create_working_files prefix.join('__'), filename
+          end
+        end
+      end
+    end
+  end
+
+  def dep
+    deps = DepAnalyzer.read_from(@deps) if File.exist?(@deps)
+    deps.each do |k, v|
+      unless v.empty?
+        puts "#{k} depends on: "
+        v.each {|f| puts "    #{f}"}
+        puts ""
+      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
+
+  def build_compiler_from_config(args)
+    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'] + args
+      
+      if opts = flags['flags'] 
+        opts.each do |k, v|
+          case v
+          when String
+            compiler_flags << v
+          when Array
+            v.each do |o|
+              compiler_flags << o
+            end
+          else
+            abort_on_err "unknown options in config.json, #{v}"
+          end
+        end
+      end
+
+      @compiler = Compiler.new compiler_name, compiler_flags
+    end
+  end
+
+  def compile(f, o)
+    @compiler.compile f, o
+  end
+
+  def link(odir, objs)
+    status = system "#{@compiler} -o #{odir}/#{@name} #{objs.join(" ")}"
+    unless status
+      puts "compilation failed"
+      return
+    end
+    
+    @compiler.link "#{odir}/#{@name}", objs
+  end
+
+  def build_bin(files, args)
+    build_compiler_from_config args
+    comps = files.select {|f| f.start_with? @components_prefix}
+    srcs = files - comps
+    
+    srcs.each do |f|
+      puts "compiling #{f}"
+      fname = f.split("/")[-1]
+      o = @obj_prefix + fname.delete_suffix(File.extname(fname)) + '.o'
+      compile f, o
+    end
+    
+    comps.each do |f|
+      puts "compiling #{f}"
+      o = @obj_prefix + f.delete_suffix(File.extname(f))[@components_prefix.length..]
+                         .gsub('/', '_') + '.o'
+      compile f, o
+    end
+    
+    link('./target', Dir.glob("obj/*.o")) unless files.empty?
+  end
+
+  def build_lib
+    puts "build a lib"
+  end
+
+  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
+
+  public
+  def inspect 
+    puts "name is #{@name}"
+    puts "name is #{@workspace}"
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: canoe
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- XIONG Ziwei
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-23 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Tired of writing Makefile, CMakeList and even SConstruct? Let Canoe help you wipe them out.
+  Similar to Cargo for Rust, Canoe offers commands such as new, build, run, etc. to help you generate a C/C++ project and build it automatically.
+  No more Makefiles, Canoe would analyze dependencies and build like our old friend make if you follow a few conventions over file names
+email: noahxiong@outlook.com
+executables:
+- canoe
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/canoe
+- lib/canoe.rb
+- lib/cmd.rb
+- lib/compiler.rb
+- lib/config_reader.rb
+- lib/default_files.rb
+- lib/dependence.rb
+- lib/err.rb
+- lib/source_files.rb
+- lib/workspace.rb
+homepage: https://github.com/Dicridon/canoe
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: a C/C++ project management and build tool
+test_files: []