jitsu 0.1.1

data/README.rdoc

@@ -0,0 +1,24 @@
+= jitsu
+
+Ninja (https://github.com/martine/ninja) is an excellent build system, but
+Ninja files are hard to write, by design. Jitsu is a simple meta build system
+that writes Ninja files for you from YAML project descriptions.
+
+For now, simple executables and static libraries are supported. See the
+features dir for examples and http://ilkka.github.com/jitsu for docs.
+
+== Contributing to jitsu
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Ilkka Laukkanen. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "jitsu"
+  gem.homepage = "http://github.com/ilkka/jitsu"
+  gem.license = "GPLv3"
+  gem.summary = %Q{Meta build system for Ninja}
+  gem.description = <<-EOS
+Jitsu is a frontend or meta build system for Ninja
+(http://github.com/martine/ninja), a lightning-fast but
+in itself (and by design) feature-poor build system.
+Jitsu reads project descriptions and generates Ninja
+buildfiles.
+EOS
+  gem.email = "ilkka.s.laukkanen@gmail.com"
+  gem.authors = ["Ilkka Laukkanen"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/bin/jitsu

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'trollop'
+require 'logger'
+
+require 'jitsu'
+
+$Log = Logger.new STDOUT
+$Log.level = Logger::WARN
+$Log.progname = "jitsu"
+
+if not Jitsu.ninja
+  warn "Could not find ninja. No surprise there."
+  exit 1
+end
+
+opts = Trollop::options do
+  version <<-EOS
+jitsu #{File.read File.join(File.dirname(__FILE__), '..', 'VERSION')}
+Copyright (C) 2011 Ilkka Laukkanen <ilkka.s.laukkanen@gmail.com>
+Licensed under the MIT License
+EOS
+  banner <<-EOS
+jitsu, the meta build system for ninja.
+
+Usage: jitsu [ OPTIONS ]
+
+where OPTIONS are one or more of the following:
+EOS
+  opt :verbose, "Be more verbose", :short => '-V'
+  opt :debug, "Output messages useful for debugging", :short => '-D'
+end
+
+$Log.level = Logger::INFO if opts[:verbose]
+$Log.level = Logger::DEBUG if opts[:debug]
+
+if not Jitsu.jitsu_file
+  warn "Could not find jitsu file"
+  exit 2
+end
+

data/cucumber.yml

@@ -0,0 +1,2 @@
+---
+default: --color

data/features/jitsu.feature

@@ -0,0 +1,69 @@
+Feature: Build C++ programs
+  In order to build C++ programs
+  As a user
+  I want to use Jitsu to generate build.ninja files
+
+  Scenario: Build a simple executable
+    Given a directory
+    And a file "main.cpp" with contents
+      """
+      #include <iostream>
+
+      int main(int argc, char* argv[]) {
+        std::cout << "Hello World" << std::endl;
+        return 0;
+      }
+      """
+    And a file "build.jitsu" with contents
+      """
+      ---
+      targets:
+        target:
+          type: executable
+          sources:
+            - main.cpp
+      """
+    When I run jitsu
+    And I run "ninja target"
+    And I run "./target"
+    Then the output should be "Hello World" with a newline
+
+  Scenario: Build an executable with a library
+    Given a directory
+    And a file "lib.cpp" with contents
+      """
+      #include <iostream>
+
+      void print_hello() {
+        std::cout << "Hello World" << std::endl;
+      }
+      """
+    And a file "main.cpp" with contents
+      """
+      void print_hello();
+
+      int main(int argc, char* argv[]) {
+        print_hello();
+        return 0;
+      }
+      """
+    And a file "build.jitsu" with contents
+      """
+      ---
+      targets:
+        hello:
+          type: executable
+          sources:
+            - main.cpp
+          dependencies:
+            - lib.a
+        lib.a:
+          type: library
+          sources:
+            - lib.cpp
+      """
+    When I run jitsu
+    And I run "ninja hello"
+    And I run "./hello"
+    Then the output should be "Hello World" with a newline
+

data/features/step_definitions/jitsu_steps.rb

@@ -0,0 +1,32 @@
+require 'tmpdir'
+
+Given /^a directory$/ do
+  @tmpdir = Dir.mktmpdir
+end
+
+Given /^a file "([^"]*)" with contents$/ do |filename, contents|
+  Dir.chdir @tmpdir do |dir|
+    File.open filename, 'w' do |f|
+      f.write contents
+    end
+  end
+end
+
+When /^I run jitsu$/ do
+  Dir.chdir @tmpdir do |dir|
+    Jitsu.output(Jitsu.read(Jitsu.jitsufile))
+  end
+end
+
+When /^I run "([^"]*)"$/ do |command|
+  parts = command.split(/ /)
+  Dir.chdir @tmpdir do |dir|
+    parts[0] = File.expand_path(parts[0]) if parts[0].index(/\//)
+    @output = `#{parts.join(' ')}`
+  end
+end
+
+Then /^the output should be "([^"]*)" with a newline$/ do |desired|
+  @output.should == desired + "\n"
+end
+

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'jitsu'
+
+require 'rspec/expectations'

data/jitsu.gemspec

@@ -0,0 +1,87 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{jitsu}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ilkka Laukkanen"]
+  s.date = %q{2011-02-13}
+  s.default_executable = %q{jitsu}
+  s.description = %q{Jitsu is a frontend or meta build system for Ninja
+(http://github.com/martine/ninja), a lightning-fast but
+in itself (and by design) feature-poor build system.
+Jitsu reads project descriptions and generates Ninja
+buildfiles.
+}
+  s.email = %q{ilkka.s.laukkanen@gmail.com}
+  s.executables = ["jitsu"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bin/jitsu",
+    "cucumber.yml",
+    "features/jitsu.feature",
+    "features/step_definitions/jitsu_steps.rb",
+    "features/support/env.rb",
+    "jitsu.gemspec",
+    "lib/jitsu.rb",
+    "spec/jitsu_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ilkka/jitsu}
+  s.licenses = ["GPLv3"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.0}
+  s.summary = %q{Meta build system for Ninja}
+  s.test_files = [
+    "spec/jitsu_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<trollop>, ["~> 1.16.2"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_development_dependency(%q<cucumber>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<trollop>, ["~> 1.16.2"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_dependency(%q<cucumber>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<trollop>, ["~> 1.16.2"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<yard>, ["~> 0.6.0"])
+    s.add_dependency(%q<cucumber>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/jitsu.rb

@@ -0,0 +1,93 @@
+require 'yaml'
+
+module Jitsu
+  JITSU_FILE_NAME = 'build.jitsu'
+  NINJA_FILE_NAME = 'build.ninja'
+
+  # Get path to ninja.
+  #
+  # @return [String] path to `ninja` or nil if ninja was not found.
+  def self.ninja
+    candidates = ENV['PATH'].split(/:/).map { |d| File.join d, 'ninja' }
+    candidates.select { |n| File.executable? n }.first
+  end
+
+  # Get path to jitsu file. Search starting from current working
+  # directory upwards.
+  #
+  # @return [String] path to jitsu file or nil if not found.
+  def self.jitsufile
+    dir = '.'
+    while File.expand_path(dir) != '/' do
+      candidate = Dir[File.join dir, JITSU_FILE_NAME].first
+      if candidate and File.readable? candidate
+        return candidate.gsub /^\.\//, ''
+      end
+      dir = File.join dir, '..'
+    end
+  end
+
+  # Read a jitsu file and output the build specification.
+  #
+  # @param jitsufile [String] path to jitsu file from e.g. Jitsu::jitsufile.
+  # @return [Hash] a hash of the build specification.
+  def self.read(jitsufile)
+    YAML.load(File.open(jitsufile, 'r').read)
+  end
+
+  # Output jitsu build specification as build.ninja file(s).
+  #
+  # @param data [Hash] a build specification from e.g. Jitsu::read.
+  # @return nil
+  def self.output(data)
+    File.open NINJA_FILE_NAME, 'w' do |f|
+      f.write <<-EOS
+cxxflags =
+ldflags =
+cxx = g++
+ld = g++
+ar = ar
+
+rule cxx
+  description = CC ${in}
+  depfile = ${out}.d
+  command = ${cxx} -MMD -MF ${out}.d ${cxxflags} -c ${in} -o ${out}
+
+rule link
+  description = LD ${out}
+  command = ${ld} ${ldflags} -o ${out} ${in}
+
+rule archive
+  description = AR ${out}
+  command = ${ar} rT ${out} ${in}
+EOS
+      data['targets'].each do |target,conf|
+        f.write "\n"
+        sources = conf['sources']
+        sources.each do |src|
+          f.write "build #{source_to_object src}: cxx #{src}\n"
+          if conf['cxxflags']
+            f.write "  cxxflags = #{conf['cxxflags']}\n"
+          end
+        end
+        f.write "build #{target}: "
+        case conf['type']
+        when 'executable'
+          f.write "link #{sources_to_objects(sources).join(' ')}"
+          f.write(' ' + conf['dependencies'].join(' ')) if conf['dependencies']
+        when 'library'
+          f.write "archive #{sources_to_objects(sources).join(' ')}"
+        end
+        f.write "\n"
+      end
+    end
+  end
+
+  def self.source_to_object(src)
+    src.gsub /\.[Cc]\w+$/, '.o'
+  end
+
+  def self.sources_to_objects(srcs)
+    srcs.map { |src| source_to_object src }
+  end
+end

data/spec/jitsu_spec.rb

@@ -0,0 +1,158 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Jitsu" do
+  it "finds ninja if ninja is in PATH" do
+    File.executable?(Jitsu.ninja).should be_true
+  end
+
+  it "fails to find ninja if ninja is not in PATH" do
+    oldpath = ENV['PATH']
+    ENV['PATH'] = ""
+    Jitsu.ninja.should == nil
+    ENV['PATH'] = oldpath
+  end
+
+  it "finds no jitsu file if a jitsu file is not present" do
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do |dir|
+        Jitsu.jitsufile.should == nil
+      end
+    end
+  end
+
+  it "finds a build.jitsu file in the current directory" do
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do |dir|
+        File.open('build.jitsu', 'w') do |f|
+          f.write 'fuubar'
+          Jitsu.jitsufile.should == 'build.jitsu'
+        end
+      end
+    end
+  end
+
+  it "finds a build.jitsu file in the parent directory" do
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do |dir|
+        File.open('build.jitsu', 'w') do |f|
+          f.write 'fuubar'
+        end
+        Dir.mkdir 'subdir'
+        Dir.chdir 'subdir' do |dir|
+          Jitsu.jitsufile.should == '../build.jitsu'
+        end
+      end
+    end
+  end
+
+  it "reads YAML from jitsu files" do
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do |dir|
+        File.open 'build.jitsu', 'w' do |f|
+          f.write <<-EOS
+---
+targets:
+  test1:
+    type: executable
+    sources: test1.cpp
+    cxxflags: -g -Wall
+    dependencies:
+      - test2
+  test2:
+    type: library
+    sources:
+      - test2.cpp
+    cxxflags: -ansi -pedantic
+EOS
+        end
+        data = Jitsu.read Jitsu.jitsufile
+        data['targets'].keys.should == ['test1', 'test2']
+      end
+    end
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do |dir|
+        File.open 'build.jitsu', 'w' do |f|
+          f.write <<-EOS
+---
+targets:
+  aaa1:
+    type: executable
+    sources:
+      - aaa1a.cpp
+      - aaa1b.cpp
+    cxxflags: -g -Wall
+    dependencies:
+      - aaa2
+  aaa2:
+    type: library
+    sources:
+      - aaa2.cpp
+    cxxflags: -ansi -pedantic
+EOS
+        end
+        data = Jitsu.read Jitsu.jitsufile
+        data['targets'].keys.should == ['aaa1', 'aaa2']
+      end
+    end
+  end
+
+  it "outputs a build.jitsu file" do
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do |dir|
+        File.open 'build.jitsu', 'w' do |f|
+          f.write <<-EOS
+---
+targets:
+  aaa1:
+    type: executable
+    sources:
+      - aaa1a.cpp
+      - aaa1b.cpp
+    cxxflags: -g -Wall
+    dependencies:
+      - aaa2.a
+  aaa2.a:
+    type: library
+    sources: 
+      - aaa2.cpp
+    cxxflags: -ansi -pedantic
+EOS
+        end
+        data = Jitsu.read Jitsu.jitsufile
+        Jitsu.output data
+        Dir['build.ninja'].length.should == 1
+        ninjafile = <<-EOS
+cxxflags =
+ldflags =
+cxx = g++
+ld = g++
+ar = ar
+
+rule cxx
+  description = CC ${in}
+  depfile = ${out}.d
+  command = ${cxx} -MMD -MF ${out}.d ${cxxflags} -c ${in} -o ${out}
+
+rule link
+  description = LD ${out}
+  command = ${ld} ${ldflags} -o ${out} ${in}
+
+rule archive
+  description = AR ${out}
+  command = ${ar} rT ${out} ${in}
+
+build aaa1a.o: cxx aaa1a.cpp
+  cxxflags = -g -Wall
+build aaa1b.o: cxx aaa1b.cpp
+  cxxflags = -g -Wall
+build aaa1: link aaa1a.o aaa1b.o aaa2.a
+
+build aaa2.o: cxx aaa2.cpp
+  cxxflags = -ansi -pedantic
+build aaa2.a: archive aaa2.o
+EOS
+        File.open('build.ninja', 'r').read.should == ninjafile
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'jitsu'
+require 'tmpdir'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end