rake-compile 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc349b9380f07be9b6c46d55bdab2a92b5ab7277
+  data.tar.gz: 89dba20f86cb03d00c3da741b5efd82aa958ea46
+SHA512:
+  metadata.gz: e2820c68fbcad6743329e7d30e843721d9640977606ff998af6ec365071e10c5f46b3ad463832e9af30fa6f96ed92fa19304217637f8f78232a92b5a8a8dd9e6
+  data.tar.gz: 62c41fa7650cd834b6b7ac36b3f96477bdd51214eaf6384cad13db8dbc2c695d994e711e35d6f6d7774f31e239f4b8813c6704431aec7ec30e657be12e8960a7

data/lib/rake-compile.rb

@@ -0,0 +1,7 @@
+require 'colorize'
+
+require_relative 'rake-compile/logging'
+require_relative 'rake-compile/install'
+require_relative 'rake-compile/compiler'
+require_relative 'rake-compile/multi_file_task'
+require_relative 'rake-compile/dsl_definition'

data/lib/rake-compile/application.rb

@@ -0,0 +1,31 @@
+module RakeCompile
+  class Application
+    attr_accessor :build_directory
+    attr_accessor :base_cpp_flags
+    attr_accessor :cpp_flags
+    attr_accessor :base_cc_flags
+    attr_accessor :cc_flags
+    attr_reader :libraries
+    attr_accessor :pch
+
+    def self.app
+      @app ||= RakeCompile::Application.new
+    end
+
+    def initialize()
+      @libraries = []
+    end
+
+    def full_cpp_flags
+      "#{self.base_cpp_flags} #{self.cpp_flags}"
+    end
+
+    def full_cc_flags
+      "#{self.base_cc_flags} #{self.cc_flags}"
+    end
+
+    def flags
+      {:cc_flags => self.full_cc_flags, :cpp_flags => self.full_cpp_flags}
+    end
+  end
+end

data/lib/rake-compile/compiler.rb

@@ -0,0 +1,19 @@
+module RakeCompile
+  def self.compiler_for_source(source, flags=nil)
+    cpp_flags = cc_flags = flags
+
+    if flags.is_a? Hash
+      cpp_flags = flags[:cpp_flags]
+      cc_flags = flags[:cc_flags]
+    end
+
+    case File.extname(source)
+    when '.cpp', '.cc', '.hpp'
+      "c++ #{cpp_flags}"
+    when ".c", ".h"
+      "cc #{cc_flags}"
+    else
+      raise("Don't know how to compile #{source}")
+    end
+  end
+end

data/lib/rake-compile/dsl_definition.rb

@@ -0,0 +1,67 @@
+require_relative 'target'
+require_relative 'application'
+
+require 'rake/clean'
+
+module RakeCompile
+  module DSL
+    def build_directory(dir)
+      directory dir
+      RakeCompile::Application.app.build_directory = dir
+    end
+
+    def base_cc_flags(flags)
+      RakeCompile::Application.app.base_cc_flags = flags
+    end
+
+    def cc_flags(flags)
+      RakeCompile::Application.app.cc_flags = flags
+    end
+
+    def base_cpp_flags(flags)
+      RakeCompile::Application.app.base_cpp_flags = flags
+    end
+
+    def cpp_flags(flags)
+      RakeCompile::Application.app.cpp_flags = flags
+    end
+
+    def link_library(library)
+      RakeCompile::Application.app.libraries << library
+    end
+
+    def pch(name)
+      RakeCompile::Application.app.pch = name
+    end
+
+    def multifile(*args, &block)
+      RakeCompile::MultiFileTask.define_task(*args, &block)
+    end
+
+    def static_library(name)
+      Target.define_static_library_task(name) do |t|
+        yield t
+      end
+
+      clear_build_state
+    end
+
+    def executable(name)
+      Target.define_executable_task(name) do |t|
+        yield t
+      end
+
+      clear_build_state
+    end
+
+    private
+    def clear_build_state
+      cpp_flags('')
+      cc_flags('')
+      RakeCompile::Application.app.libraries.clear()
+      RakeCompile::Application.app.pch = nil
+    end
+  end
+end
+
+self.extend RakeCompile::DSL

data/lib/rake-compile/install.rb

@@ -0,0 +1,11 @@
+module RakeCompile
+  def self.install(src, dst)
+    RakeCompile.log("INSTALL".yellow, dst)
+    FileUtils.rm_f(dst)
+    FileUtils.cp(src, dst)
+  end
+  def self.uninstall(path)
+    RakeCompile.log("UNINSTALL".yellow, path)
+    FileUtils.rm_rf(path)
+  end
+end

data/lib/rake-compile/logging.rb

@@ -0,0 +1,5 @@
+module RakeCompile
+  def self.log(key, msg)
+    puts "[#{key}] #{msg}"
+  end
+end

data/lib/rake-compile/multi_file_task.rb

@@ -0,0 +1,8 @@
+module RakeCompile
+  class MultiFileTask < Rake::FileTask
+    private
+    def invoke_prerequisites(task_args, invocation_chain)
+      invoke_prerequisites_concurrently(task_args, invocation_chain)
+    end
+  end
+end

data/lib/rake-compile/target.rb

@@ -0,0 +1,196 @@
+require_relative 'application'
+require_relative 'dsl_definition'
+
+module RakeCompile
+  class Target
+    include Rake::DSL
+
+    attr_reader :objects
+    attr_reader :name
+    attr_accessor :libraries
+    attr_accessor :pch
+
+    def self.define_executable_task(name)
+      target = Target.new(name)
+
+      yield target
+
+      target.define_task() do |t|
+        t.create_executable()
+      end
+    end
+
+    def self.define_static_library_task(name)
+      target = Target.new(name)
+
+      yield target
+
+      target.define_task() do |t|
+        t.create_static_library()
+      end
+    end
+
+    def initialize(a_name)
+      @name = a_name
+      @objects = []
+
+      self.setup_pch_task()
+    end
+
+    def setup_pch_task
+      return if RakeCompile::Application.app.pch.nil?
+
+      pch_source = RakeCompile::Application.app.pch
+      pch_output = pch_source.ext('.gch')
+      pch_output = File.join(RakeCompile::Application.app.build_directory, pch_output)
+      self.pch   = File.absolute_path(pch_output)
+
+      define_object_dependencies(pch_source, self.pch)
+    end
+
+    def append_pch_to_flags(pch_file, flags)
+      flags = flags.dup
+
+      # Remove the extension.  I'm not certain why this is necessary, but clang freaks out if you do not.
+      pch_file = pch_file.ext('')
+      pch_flag = " -include '#{pch_file}'"
+      flags[:cc_flags] += pch_flag
+      flags[:cpp_flags] += pch_flag
+      flags
+    end
+
+    def define_task()
+      CLOBBER.include(self.name)
+
+      dir = File.dirname(self.name)
+      directory dir
+
+      # Capture libraries, for use in the block below.  We need to dup the array,
+      # because the app copy gets mutated, and we don't just want a reference.
+      self.libraries = RakeCompile::Application.app.libraries.dup
+
+      prereqs = [dir, self.objects, self.libraries].flatten
+
+      RakeCompile::MultiFileTask.define_task(self.name => prereqs) do
+        yield self
+      end
+    end
+
+    def create_executable()
+      FileUtils.rm_f(self.name)
+
+      RakeCompile.log("BIN".light_blue, self.name)
+      linker = 'c++ -std=c++11 -stdlib=libc++'
+
+      inputs = self.objects.join("' '")
+      libs = self.libraries.join("' '")
+
+      cmd = "#{linker}"
+      cmd += " -o '#{self.name}'"
+      cmd += " '#{inputs}'"
+      cmd += " '#{libs}'" if libs.length > 0
+
+      Rake::sh(cmd)
+    end
+
+    def create_static_library()
+      FileUtils.rm_f(self.name)
+
+      inputs = self.objects.join("' '")
+
+      RakeCompile.log("LIB".light_blue, self.name)
+      Rake::sh("/usr/bin/ar crs '#{self.name}' '#{inputs}'")
+    end
+
+    def add_objects_from_sources(filelist, flags=nil)
+      filelist.each { |source| self.add_object_from_source(source, flags) }
+    end
+
+    def add_object_from_source(source, flags=nil)
+      object = File.join(RakeCompile::Application.app.build_directory, source.ext('.o'))
+
+      add_object(source, object, flags)
+    end
+
+    def add_object(source, object, flags=nil)
+      object = File.absolute_path(object)
+      @objects << object
+
+      define_object_dependencies(source, object, flags)
+    end
+
+    def define_object_dependencies(source, object, flags=nil)
+      flags ||= RakeCompile::Application.app.flags
+
+      source = File.absolute_path(source)
+      dependency_file = "#{object}.deps"
+
+      deps = []
+      if File.exist?(dependency_file)
+        deps = dependencies_from_deps_file(dependency_file)
+      end
+
+      dir = File.dirname(dependency_file)
+      directory dir
+
+      # define a file task to create the deps file, which
+      # depends on the dependencies themselves.  Also
+      # depends on the directory that contains it
+      if self.pch && (object != self.pch)
+        file(dependency_file => self.pch)
+        flags = append_pch_to_flags(self.pch, flags)
+      end
+
+      file dependency_file => dir
+      file dependency_file => deps do
+        RakeCompile.log("DEPS".red, object)
+        deps = dependencies_for_source(source, flags)
+
+        File.open(dependency_file, "w+") do |file|
+          file << deps.join("\n")
+          file << "\n"
+        end
+      end
+
+      # and, now define the actual object file itself
+      file object => [dir, dependency_file] do
+        s = RakeCompile.compiler_for_source(source, flags)
+        s += " -o '#{object}'"
+        s += " -c '#{source}'"
+
+        RakeCompile.log("OBJ".yellow, object)
+        Rake::sh(s)
+      end
+
+      # make sure these are cleaned
+      CLEAN.include(dependency_file)
+      CLEAN.include(object)
+    end
+
+    def dependencies_for_source(source, flags)
+      s = RakeCompile::compiler_for_source(source, flags)
+      s += " -MM "
+      s += "'#{source}'"
+
+      puts s if verbose() != false
+      output = `#{s}`.chomp()
+
+      output.gsub!(" \\\n  ", " ")
+
+      dependencies = output.split(" ")
+      dependencies.delete_at(0)  # remove the first element, which is the object file itself
+      dependencies.reject! { |x| x.empty? } # remove blanks
+
+      dependencies.collect { |x| File.absolute_path(x) }
+    end
+
+    def dependencies_from_deps_file(path)
+      deps = []
+      File.open(path, 'r') do |file|
+        deps = file.readlines()
+      end
+
+      deps.collect {|x| x.chomp() }
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: rake-compile
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matt Massicotte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rake-compile is a set of rake tasks and utitlies to help build native
+  projects
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rake-compile/application.rb
+- lib/rake-compile/compiler.rb
+- lib/rake-compile/dsl_definition.rb
+- lib/rake-compile/install.rb
+- lib/rake-compile/logging.rb
+- lib/rake-compile/multi_file_task.rb
+- lib/rake-compile/target.rb
+- lib/rake-compile.rb
+homepage: https://github.com/mattmassicotte/rake-compile
+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: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Rake-compile makes it easier to use rake to build native projects
+test_files: []