jank 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c7b5f0d00fc555316cdbd2b1b036eb5b2cd56d7
+  data.tar.gz: 58b6eccf657e1f623a5eb6e7e2d4d4c955d30dca
+SHA512:
+  metadata.gz: 95aaed1454cd31109c374c9a758cd0f36c69e632f45208399f341d72741bd652af145b185a365fffc78514176a851bb53a85918027dd5381e8c48ebadfa66f8d
+  data.tar.gz: 336bfb20761a261a73484d01b0f6fe180ee6d61796cb4c64e0c197b7affe4b91a90ddab7f4fb206d818afe9fa1f80708c867e213bb76ee31b5b88f9e822e4e28

data/bin/jank

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/base'
+require_relative '../lib/jank_command'
+
+module Jank
+  def self.main
+    config = Config.new
+    JankCommand.new(ARGV, config, Janker.new(config), Executor.new(config)).dispatch
+  end
+end
+
+Jank.main

data/bin/jgo

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/base'
+require_relative '../lib/go'
+require_relative '../lib/go_command'
+
+module Jank
+  def self.main
+    config = Config.new
+    GoCommand.new(ARGV, config, Janker.new(config), Go.new(config)).dispatch
+  end
+end
+
+Jank.main

data/bin/jgocode

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/base'
+require_relative '../lib/gocode_command'
+
+module Jank
+  def self.main
+    config = Config.new
+    GocodeCommand.new(ARGV, config, Janker.new(config), Executor.new(config)).dispatch
+  end
+end
+
+Jank.main

data/bin/jgodoc

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/base'
+require_relative '../lib/godoc_command'
+
+module Jank
+  def self.main
+    config = Config.new
+    GodocCommand.new(ARGV, config, Janker.new(config), Executor.new(config)).dispatch
+  end
+end
+
+Jank.main

data/bin/jgofmt

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/base'
+require_relative '../lib/gofmt_command'
+
+module Jank
+  def self.main
+    config = Config.new
+    GofmtCommand.new(ARGV, config, Janker.new(config), Executor.new(config)).dispatch
+  end
+end
+
+Jank.main

data/bin/jgoimports

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/base'
+require_relative '../lib/goimports_command'
+
+module Jank
+  def self.main
+    config = Config.new
+    GoimportsCommand.new(ARGV, config, Janker.new(config), Executor.new(config)).dispatch
+  end
+end
+
+Jank.main

data/bin/jgolint

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/base'
+require_relative '../lib/golint_command'
+
+module Jank
+  def self.main
+    config = Config.new
+    GolintCommand.new(ARGV, config, Janker.new(config), Executor.new(config)).dispatch
+  end
+end
+
+Jank.main

data/lib/base.rb

@@ -0,0 +1,6 @@
+require_relative '../lib/config'
+require_relative '../lib/debug'
+require_relative '../lib/executor'
+require_relative '../lib/janker'
+
+Jank.debug_log("#{$0} #{ARGV.inspect}")

data/lib/command.rb

@@ -0,0 +1,19 @@
+module Jank
+  class Command
+    def initialize(args, config, janker, executor)
+      @config = config
+      @janker = janker
+      @exec = executor
+      @args = args
+    end
+
+    def dispatch
+      command = "#{@args[0]}_command"
+      if !self.respond_to? command
+        command = 'help'
+      end
+
+      self.send(command)
+    end
+  end
+end

data/lib/config.rb

@@ -0,0 +1,135 @@
+require 'yaml'
+
+module Jank
+  class Config
+    attr_reader :go, :gopaths, :janked_gopaths, :pwd, :home, :package, :janked_packge, :janked, :rsync, :janked_local_path, :janked_gopath, :janked, :local_gopath, :env
+
+    def initialize
+      # Ignore or include ENV gopath
+      @include_env_gopath = nil
+
+      # Path to go
+      @go = ENV['JANK_GO'] || `which go`.chomp
+
+      # Path to rsync
+      @rsync = ENV['JANK_RSYNC'] || `which rsync`.chomp
+
+      if @go.empty?
+        STDERR.write "go not found"
+        exit(1)
+      end
+
+      if @rsync.empty?
+        STDERR.write "rsync not found"
+        exit(1)
+      end
+
+      # Working directory
+      if ENV.has_key? 'TM_DIRECTORY'
+        @pwd = ENV['TM_DIRECTORY']
+      else
+        @pwd = Dir.pwd
+      end
+
+      # Home directory
+      @home = Dir.home
+
+      # Current Go package
+      @package = nil
+
+      # Janked Go package (might be higher in the filesystem than the current package)
+      @janked_package = nil
+
+      # Path to root of go package in gopath
+      @janked_gopath = nil
+
+      # Path to root of go package in local project
+      @janked_local_path = nil
+
+      # true if this package is to be janked into a gopath
+      @janked = false
+
+      # ENV supplied gopaths
+      @gopaths = ENV['GOPATH'] || ENV['JANK_GOPATH'] || ENV['TM_GOPATH']
+      if @gopaths == nil
+        @gopaths = Array.new
+      else
+        @gopaths = @gopaths.split(/:/).select {|p| p != ''}
+      end
+
+      # Array of janked_gopaths
+      @janked_gopaths = Array.new
+
+      # The gopath that contains the working directory, null if janked
+      @local_gopath = nil
+
+      read_config_files
+
+      @env = ENV
+
+      if @include_env_gopath == false
+        @env['GOPATH'] = @gopaths.uniq.join(':')
+      else
+        @env['GOPATH'] = (@janked_gopaths + @gopaths).uniq.join(':')
+      end
+
+      Jank.debug_log("GOPATH = #{@env['GOPATH']}")
+    end
+
+    private
+    def read_config_files
+      curdir = @pwd
+      parse_config(curdir)
+
+      until curdir == @home do
+        curdir = File.expand_path('..', curdir)
+        parse_config(curdir)
+      end
+    end
+
+    def parse_config(dir)
+      return if !File.exist?("#{dir}/.jank")
+      yaml = YAML.load_file("#{dir}/.jank")
+
+      if @include_env_gopath == nil && yaml.has_key?('env_gopath') && !yaml['env_gopath'].empty?
+        if yaml['env_gopath'] == 0 || yaml['env_gopath'] =~/false/i
+          @include_env_gopath = false
+        else
+          @include_env_gopath = true
+        end
+      end
+
+      if @local_gopath == nil && @janked_package == nil && yaml.has_key?('package') && !yaml['package'].empty?
+        @janked_package = yaml['package']
+        @janked = true
+
+        if @gopaths.length > 0
+          @janked_local_path = dir
+          @janked_gopath = "#{@gopaths.first}/src/#{@janked_package}"
+          @package = @pwd.gsub(/^#{@janked_local_path}/, @janked_package)
+        end
+      end
+
+      if yaml.has_key?('gopath')
+        if !yaml['gopath'].kind_of?(Array)
+          yaml['gopath'] = Array.new( yaml['gopath'] )
+        end
+
+        yaml['gopath'].each do |gp|
+          gp = abs_gopath(dir, gp)
+          @janked_gopaths << gp
+
+          if @local_gopath == nil && !@janked && @pwd.start_with?(gp)
+            @local_gopath = gp
+            @package = @pwd.slice((@local_gopath.length + 5)..(@pwd.length))
+          end
+        end
+      end
+    end
+
+    def abs_gopath(dir, gp)
+      return gp if gp =~ /^\//
+      File.realpath("#{dir}/#{gp}")
+    end
+  end
+end

data/lib/debug.rb

@@ -0,0 +1,9 @@
+module Jank
+  def Jank.debug_log(msg)
+    if ENV.has_key? 'JANK_DEBUG'
+      open("/tmp/jank.log", 'a') do |f|
+        f.puts msg
+      end
+    end
+  end
+end

data/lib/executor.rb

@@ -0,0 +1,40 @@
+require_relative 'debug'
+
+module Jank
+  class Executor
+    def initialize(c)
+      @config = c
+    end
+
+    def apply_package(args)
+      return args if @config.package == nil
+
+      new_args = Array.new
+      package_applied = false
+
+      args.each do |a|
+        case a
+        when /^\./
+          package_applied = true
+          new_args << a.gsub(/^\./, @config.package)
+        when /\//
+          package_applied = true
+          new_args << a
+        when /\.go$/
+          package_applied = true
+          new_args << a
+        else
+          new_args << a
+        end
+      end
+
+      new_args << @config.package if !package_applied
+      new_args
+    end
+
+    def execute(cmd, args)
+      Jank.debug_log("🚀  #{cmd} #{args.inspect}")
+      Kernel.exec(@config.env, cmd, *args)
+    end
+  end
+end

data/lib/go.rb

@@ -0,0 +1,9 @@
+require_relative 'executor'
+
+module Jank
+  class Go < Executor
+    def go(args)
+      execute(@config.go, args)
+    end
+  end
+end

data/lib/go_command.rb

@@ -0,0 +1,76 @@
+require_relative 'command'
+
+module Jank
+  class GoCommand < Command
+    def run_go
+      @janker.link
+      @exec.go(@args)
+    end
+
+    def run_go_with_janked_package
+      @janker.link
+      @exec.go( @exec.apply_package(@args) )
+    end
+
+    def build_command
+      run_go_with_janked_package
+    end
+
+    def clean_command
+      run_go_with_janked_package
+    end
+
+    def env_command
+      run_go
+    end
+
+    def fix_command
+      run_go_with_janked_package
+    end
+
+    def fmt_command
+      run_go_with_janked_package
+    end
+
+    def help
+      run_go
+    end
+
+    def generate_command
+      run_go_with_janked_package
+    end
+
+    def get_command
+      run_go
+    end
+
+    def install_command
+      run_go_with_janked_package
+    end
+
+    def list_command
+      @janker.link
+      run_go_with_janked_package
+    end
+
+    def run_command
+      run_go
+    end
+
+    def test_command
+      run_go_with_janked_package
+    end
+
+    def tool_command
+      run_go
+    end
+
+    def version_command
+      run_go
+    end
+
+    def vet_command
+      run_go_with_janked_package
+    end
+  end
+end

data/lib/gocode_command.rb

@@ -0,0 +1,20 @@
+require_relative 'command'
+
+module Jank
+  class GocodeCommand < Command
+    def initialize(args, config, janker, executor)
+      super(args, config, janker, executor)
+
+      @gocode = ENV['JANK_GOCODE'] || `which gocode`.chomp
+      if @gocode.empty?
+        puts "gocode is not installed. See https://github.com/nsf/gocode"
+        exit(1)
+      end
+    end
+
+    def dispatch
+      @janker.link
+      @exec.execute(@gocode, @args)
+    end
+  end
+end

data/lib/godoc_command.rb

@@ -0,0 +1,20 @@
+require_relative 'command'
+
+module Jank
+  class GodocCommand < Command
+    def initialize(args, config, janker, executor)
+      super(args, config, janker, executor)
+
+      @godoc = ENV['JANK_GODOC'] || `which godoc`.chomp
+      if @godoc.empty?
+        puts "gocode is not installed. Run:\n  go get code.google.com/p/go.tools/cmd/godoc"
+        exit(1)
+      end
+    end
+
+    def dispatch
+      @janker.link
+      @exec.execute(@godoc, @args)
+    end
+  end
+end

data/lib/gofmt_command.rb

@@ -0,0 +1,20 @@
+require_relative 'command'
+
+module Jank
+  class GofmtCommand < Command
+    def initialize(args, config, janker, executor)
+      super(args, config, janker, executor)
+
+      @gofmt = ENV['JANK_GOFMT'] || `which gofmt`.chomp
+      if @gofmt.empty?
+        puts "gofmt is not installed. See: https://golang.org/cmd/gofmt/"
+        exit(1)
+      end
+    end
+
+    def dispatch
+      @janker.link
+      @exec.execute(@gofmt, @args)
+    end
+  end
+end

data/lib/goimports_command.rb

@@ -0,0 +1,20 @@
+require_relative 'command'
+
+module Jank
+  class GoimportsCommand < Command
+    def initialize(args, config, janker, executor)
+      super(args, config, janker, executor)
+
+      @goimports = ENV['JANK_GOIMPORTS'] || `which goimports`.chomp
+      if @goimports.empty?
+        puts "goimports is not installed. See http://godoc.org/golang.org/x/tools/cmd/goimports"
+        exit(1)
+      end
+    end
+
+    def dispatch
+      @janker.link
+      @exec.execute(@goimports, @args)
+    end
+  end
+end

data/lib/golint_command.rb

@@ -0,0 +1,21 @@
+require_relative 'command'
+
+module Jank
+  class GolintCommand < Command
+    def initialize(args, config, janker, executor)
+      super(args, config, janker, executor)
+
+      @golint = ENV['JANK_GOLINT'] || `which golint`.chomp
+      if @golint.empty?
+        puts "golint is not installed. See https://github.com/golang/lint"
+        exit(1)
+      end
+    end
+
+    def dispatch
+      @args = @exec.apply_package(@args)
+      @janker.link
+      @exec.execute(@golint, @args)
+    end
+  end
+end

data/lib/jank_command.rb

@@ -0,0 +1,174 @@
+require_relative 'command'
+
+module Jank
+  class JankCommand < Command
+    def config_command
+      puts @config.to_yaml
+    end
+
+    def help
+      topic_help = "#{@args[1]}_help_text"
+      if self.respond_to? topic_help
+        puts self.send(topic_help)
+      else
+        puts jank_help_text
+      end
+    end
+
+    def gopath_command
+      puts @config.env['GOPATH']
+    end
+
+    def link_command
+      puts "Package #{@config.package || '[UNKNOWN]'} is not jankable" if !@janker.link
+    end
+
+    def package_command
+      @janker.sync_packages
+
+      if ARGV[1] == '-r' || ARGV[1] == '--reverse'
+        package = ARGV[2]
+        if package == nil
+          puts package_help_text
+          exit(1)
+        end
+
+        puts @janker.location_of_package(package)
+        exit
+      end
+
+      path = ARGV[1]
+      if path == nil
+        puts @config.package
+        exit
+      end
+
+      puts @janker.package_for_location path
+    end
+
+    def stat_command
+      @janker.sync_packages
+      @janker.walk_janked_packages do |package, local_path, go_path|
+        puts "#{package} --> #{local_path}"
+      end
+    end
+
+    def sync_command
+      @janker.sync_packages
+    end
+
+    def unlink_command
+      all = @args[1] == '-a' || @args[1] == '--all'
+
+      if all
+        @janker.unlink_all
+      else
+        puts "Package #{@config.package || '[UNKNOWN]'} is not jankable" if !@janker.unlink
+      end
+    end
+
+    def jank_help_text
+<<-HELPTEXT
+Jank - the janky Go build tool.
+
+Usage:
+
+	jank command [arguments]
+
+The commands are:
+
+    config      show the jank configuration for the directory
+    gopath      displays gopath for the directory
+    help        show this!
+    link        link a go-gettable source tree into the gopath
+    package     displays the package for the current directory
+    stat        lists packages linked into gopath
+    sync        syncs packages linked into gopath
+    unlink      unlink a go-gettable source tree from the gopath
+
+Use "jank help [command]" for more information about a command.
+HELPTEXT
+    end
+
+    def config_help_text
+<<-HELPTEXT
+usage: jank config
+
+Displays the jank configuration for the current directory.
+HELPTEXT
+    end
+
+    def gopath_help_text
+<<-HELPTEXT
+usage: jank path
+
+Displays additional gopaths for this directory. Paths can
+be added by placing .jank files in directories with the
+key 'gopath'. The gopath key can map to a string or an array
+of additional gopaths. Gopaths are scanned for in this manner
+up the filesystem until the user's home directory.
+
+Gopaths specified in the .jank file can be either absolute
+paths or paths relative to the directory.
+HELPTEXT
+    end
+
+    def link_help_text
+<<-HELPTEXT
+usage: jank link
+
+For packages developed in a go-gettable stlye outside the
+gopath, invoking link will link the package into the gopath.
+This requires that the directory or some parent contains a
+.jank file with the 'package' key set to go package name.
+HELPTEXT
+    end
+
+    def package_help_text
+<<-HELPTEXT
+usage: jank package [flags] [path]
+
+Flags:
+    -r, --reverse
+                  Return directory for go package
+
+Displays the package for the current directory or the path
+if specified. Specifiying the reverse flag returns the
+filesystem path of a go package.
+HELPTEXT
+    end
+
+    def stat_help_text
+<<-HELPTEXT
+usage: jank stat
+
+Displays a mapping of packages in the gopath that are linked
+to go-gettable source trees that reside outside of the gopath.
+HELPTEXT
+    end
+
+    def sync_help_text
+<<-HELPTEXT
+usage: jank sync
+
+Syncs all packages linked into the gopath.
+HELPTEXT
+    end
+
+    def unlink_help_text
+<<-HELPTEXT
+usage: jank unlink [flags]
+
+Flags:
+    -a, --all
+                  Unlink all linked packages
+
+For packages developed in a go-gettable stlye outside the
+gopath, invoking unlink will remove the package from the
+gopath. This requires that the directory or some parent
+contains a .jank file with the 'package' key set to go
+package name.
+HELPTEXT
+    end
+  end
+end

data/lib/janker.rb

@@ -0,0 +1,126 @@
+require 'fileutils'
+require 'find'
+
+module Jank
+  class Janker
+    def initialize(config)
+      @config = config
+    end
+
+    def link
+      return false if !@config.janked
+      mark_janked_package
+      sync_packages
+      true
+    end
+
+    def unlink
+      return false if !@config.janked
+      unmark_janked_package
+      sync_packages
+      true
+    end
+
+    def package_for_location(path)
+      Dir.chdir(File.realpath(path)) do
+        conf = Config.new
+        return conf.package
+      end
+    end
+
+    def location_of_package(pkg)
+      local_gp = nil
+      path = nil
+
+      # Find location in gopath
+      (@config.janked_gopaths + @config.gopaths).each do |gp|
+        path = "#{gp}/src/#{pkg}"
+        next if !File.exist?(path) || !File.directory?(path)
+        local_gp = gp
+        break
+      end
+
+      return "" if local_gp == nil
+
+      # Translate path if janked
+      root = "#{local_gp}/src"
+      dir = path
+      janked_path = nil
+      janked_location = nil
+
+      while dir != root
+        jankfile = "#{dir}/JANKED"
+        if File.exist?(jankfile)
+          janked_path = dir
+          janked_location = File.read(jankfile)
+          break
+        end
+
+        dir = File.realpath("#{dir}/..")
+      end
+
+      if janked_path != nil
+        return path.gsub(/^#{janked_path}/, janked_location)
+      end
+
+      return path
+    end
+
+    def walk_janked_packages
+      @config.gopaths.each do |gp|
+        Find.find("#{gp}/src") do |path|
+          next if !FileTest.directory?(path)
+          Find.prune if File.basename(path).start_with? '.'
+
+          janked_file = "#{path}/JANKED"
+          if File.exist?(janked_file)
+            package = path.slice(gp.length+5..path.length)
+            yield package, File.read(janked_file), path
+            Find.prune
+          end
+        end
+      end
+    end
+
+    def mark_janked_package
+      if @config.janked_local_path.start_with? @config.janked_gopath
+        raise "Trying to link a package already inside the gopath!"
+      end
+
+      FileUtils.mkdir_p(@config.janked_gopath)
+      File.open("#{@config.janked_gopath}/JANKED", 'w') {|f| f.write(@config.janked_local_path) }
+    end
+
+    def unmark_janked_package
+      if File.exist?(@config.janked_gopath)
+        FileUtils.rm_rf(@config.janked_gopath)
+      end
+    end
+
+    def sync_packages
+      walk_janked_packages do |package, local_path, go_path|
+        if File.exist?(local_path) && File.directory?(local_path) && ! File.symlink?(local_path)
+          rsync(local_path, go_path)
+        else
+          FileUtils.rm_rf(go_path)
+        end
+      end
+    end
+
+    def unlink_all
+      walk_janked_packages do |package, local_path, go_path|
+        FileUtils.rm_rf(go_path)
+      end
+    end
+
+    def rsync(src, dest)
+      return if src == dest
+
+      exclude = %w{JANKED .bzr .bzringore .hg .hgignore .git .gitignore .nfs}
+      opts = "--delete"
+      exclude.each {|e| opts += " --exclude #{e}"}
+
+      `rsync -az #{opts} "#{src}/" "#{dest}"`
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: jank
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fred McCann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-17 00:00:00.000000000 Z
+dependencies: []
+description: Jank is a suite of scripts that wrap the go command and a collection
+  of utility commands for go programming. Jank will rewrite the gopath dynamically
+  to support development of go-gettable and arbitrarily laid out projects outside
+  of a global gopath. These tools can be subsituted for the real versions to transparently
+  augment their behavior.
+email:
+- fred@sharpnoodles.com
+executables:
+- jank
+- jgo
+- jgocode
+- jgodoc
+- jgofmt
+- jgoimports
+- jgolint
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/jank
+- bin/jgo
+- bin/jgocode
+- bin/jgodoc
+- bin/jgofmt
+- bin/jgoimports
+- bin/jgolint
+- lib/base.rb
+- lib/command.rb
+- lib/config.rb
+- lib/debug.rb
+- lib/executor.rb
+- lib/go.rb
+- lib/go_command.rb
+- lib/gocode_command.rb
+- lib/godoc_command.rb
+- lib/gofmt_command.rb
+- lib/goimports_command.rb
+- lib/golint_command.rb
+- lib/jank_command.rb
+- lib/janker.rb
+homepage: http://gojank.com
+licenses:
+- BSD
+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.4.7
+signing_key: 
+specification_version: 4
+summary: jank - the janky Go build tool
+test_files: []