wad 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a1b10e3871e52d7c16f10d19fe4309ad1b139e2a
+  data.tar.gz: 87f4f52ba33d1ed5591252d00b234861073bb005
+SHA512:
+  metadata.gz: d4e44bbb4bebad9f1e31b3d12c32f670a10f8c176cda11d5d018cb57f8b4722cb1256ca63ff66f5da685ca838cf56cf867206793e00132d6db4b12b647c33e12
+  data.tar.gz: 5cd247d3a93716847cd5758ce1de8dec73c8946de11563fc06b1847645a59070c1c41ce813b6d6765cc53701d30deceb63abe15329e3c7ecb35bdff9f1838d4c

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+
+ Copyright (c) 2015 Kaspar Schiess
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,71 @@
+
+NAME
+
+wad - rolls all your libraries in a big wad, ghetto style
+
+After rubygems and bundler, let us take you full circle and go back to a 
+lib directory that contains all your libraries. Except now, it's per project. 
+
+SYNOPSIS
+
+  $ wad roll      # installs all your libs into 'vendor/lib', by default. 
+
+DESCRIPTION
+
+Since we're all following very strict standards with regards to how our gems 
+are constructed, we might as well pack all those gems back into a directory 
+and use that directory in our load path. 
+
+Once you do that, you'll discover that loading from all these paths and doing 
+dependency resolution cost on every ruby invocation. On our machines, using 
+wad saves us >500ms every time, on every call. 
+
+Wad helps you with getting there: It vendors your Gemfile below `vendor/bundle`, 
+then copies relevant source code to `vendor/lib`. All in one simple call. 
+
+After that, the standard code for augmenting the load path in your binaries 
+becomes: 
+
+  require 'pathname'
+  root = Pathname.new(__FILE__).dirname.join('..').expand_path
+  %w(vendor/lib lib).each { |p| $:.unshift(root.join(p)) }
+
+  require 'mylib' # And it's simple requires from then on. 
+
+It might be useful to extend your (bash) .profile with something like this: 
+
+  function be() {
+    if [[ -d vendor/lib ]]; then 
+      RUBYOPT="-I vendor/lib" command $*
+    else 
+      if [[ -a Gemfile ]]; then
+        bundle exec $*
+      else
+        command $*
+      fi
+    fi
+  }
+  alias ruby="be ruby"
+  alias rake="be rake"
+  alias rspec="be rspec"
+  alias irb="be irb"
+
+This way, you don't notice wad. Except that it boots real quick. 
+
+INSTALL
+
+  $ gem install wad
+
+BUGS
+
+This is new and will get you into all sorts of trouble, unless you know what 
+you're doing. But if you don't, you're in trouble anyway. In short: if any 
+milk gets spilt, don't expect us to lick it. 
+
+COPYRIGHT
+
+MIT. See LICENSE file.
+
+AUTHORS
+
+Resident Astronauts: Kaspar Schiess (Technology Astronauts dot ch) & Florian Hanke (Technology Astronauts dot ch)

data/bin/wad

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require 'clamp'
+
+$:.unshift Pathname.new(__FILE__).dirname.join('../lib')
+require 'wad/compiler'
+
+class CompileCommand < Clamp::Command
+  option '--root', "PROJECT_ROOT", 'root of the project to compile'
+
+  def execute
+    compiler = Wad::Compiler.new(root || Pathname.new(Dir.pwd))
+    compiler.compile
+  end
+end
+
+class WadApp < Clamp::Command
+  subcommand 'roll', 'rolls your library in a big wad in vendor/lib', CompileCommand
+end
+
+WadApp.run

data/lib/wad/bundle.rb

@@ -0,0 +1,52 @@
+
+require 'mixlib/shellout'
+
+module Wad
+  # Interaction with bundler THROUGH THE COMMAND LINE SINCE THE CODE IS REALLY
+  # COMPLICATED.
+  #
+  class Bundle
+    class LiveDelegator
+      def initialize &block
+        @block = block
+      end
+
+      def << buffer
+        buffer.lines.each do |line|
+          @block.call(line.chomp)          
+        end
+      end
+    end
+
+    def install &block
+      status = bundle(:install, live_stream: LiveDelegator.new(&block))
+      ! status.error?
+    end
+
+    def list *a
+      cmd = bundle(:list, *a, raise_on_error: true)
+      cmd.stdout
+    end
+
+  private
+    def bundle *a, **opts
+      raise_on_error = opts.delete(:raise_on_error)
+
+      timeout = 60*60 # seconds
+      a = a.map { |e| e.to_s }
+      a.unshift 'bundle'
+
+      runner = Mixlib::ShellOut.new(
+        *a, 
+        opts.merge(timeout: timeout))
+
+      runner.run_command
+
+      if raise_on_error
+        runner.error!
+      end
+
+      runner
+    end
+  end
+end

data/lib/wad/compiler.rb

@@ -0,0 +1,93 @@
+
+
+require 'fileutils'
+
+require 'rubygems/specification'
+
+require 'wad/gem'
+require 'wad/target'
+require 'wad/reporter'
+require 'wad/bundle'
+
+module Wad
+  class Compiler
+
+    attr_reader :root
+    attr_reader :reporter
+    attr_reader :bundle
+
+    # Constructs a new compiler which will do its work in root/vendor, copying
+    # vendor/bundle to vendor/lib.
+    # 
+    # @param root [Pathname] root of the project
+    #
+    def initialize root
+      @root = root
+      @reporter = Reporter.new
+      @bundle = Bundle.new
+    end
+
+    def compile
+      target = Target.new(root, 'vendor/lib', reporter)
+
+      empty(target)
+      bundle_install or raise "Please fix bundler failures first."
+      copy_files(target)
+    end
+
+    def empty target
+      reporter.report_emptying(target)
+      # Danger.
+      FileUtils.rm_rf(target.path)
+    end
+
+    def bundle_install
+      status = false # declare local var
+
+      reporter.report_bundle_install do
+        status = bundle.install do |line|
+          reporter.report_bundle_install_line(line)
+        end
+      end
+
+      status
+    end
+
+    def copy_files target
+      reporter.report_copy_phase(target)
+
+      # my editor messes up highlighting upon encountering 'gem'... so ghem it is. 
+      each_gem do |ghem| 
+        reporter.report_copy_for(ghem) do
+          ghem.each_lib_file do |file|
+            # We can't 'copy' directories
+            next if file.directory?
+
+            file.copy(target)
+          end
+        end
+      end
+    end
+
+  private
+
+    def each_gem
+      bundle_list do |path, spec|
+        yield Gem.new(path, spec)
+      end
+    end
+
+    # @yield path_to_gem, gem_spec
+    #
+    def bundle_list
+      bundle.list('--paths').lines.each do |line|
+        path = Pathname.new(line.chomp)
+
+        gemspec_file = Pathname.glob(path.join('*.gemspec')).first
+        spec = ::Gem::Specification.load(gemspec_file.to_s)
+
+        yield path, spec
+      end
+    end
+  end
+end

data/lib/wad/file.rb

@@ -0,0 +1,34 @@
+
+module Wad
+
+  # A file that is part of a gem. 
+  #
+  class File
+    # Full file path
+    attr_reader :path
+
+    # Relative path this file should have after the copy
+    attr_reader :to
+
+    # Gem this belongs to
+    attr_reader :ghem
+
+    def initialize ghem, path, to
+      @ghem = ghem
+      @path = path
+      @to = to
+    end
+
+    def copy target
+      target.copy(self)
+    end
+
+    def gem_name
+      ghem.name
+    end
+
+    def directory?
+      path.directory?
+    end
+  end
+end

data/lib/wad/gem.rb

@@ -0,0 +1,49 @@
+
+require 'wad/file'
+
+module Wad
+
+  # Our internal representation of a gem that we copy files from. 
+  #
+  class Gem
+    # Base directory of the gem version
+    attr_reader :base
+    # Name of the gem, currently including the version
+    attr_reader :name
+    # @return [Gem::Specification] loaded gemspec
+    attr_reader :spec
+
+    def initialize path, spec
+      @base = path
+      @spec = spec
+      @name = path.split.last.to_s
+    end
+
+    def each_lib_file
+      each_require_path do |subdir|
+        subdir_path = base.join(subdir)
+
+        wildcard = base.join("#{subdir}/**/*")
+        Pathname.glob(wildcard).each do |path|
+          yield File.new(self, path, path.relative_path_from(subdir_path))
+        end
+      end
+    end
+
+    def each_require_path &block
+      if spec
+        # Filter the require paths to not include: 
+        #   a) '.', because that would mess up the toplevel dir in vendor/lib
+        #   b) '../...', because those paths mostly point to bundles, 
+        #     which also exist in lib!
+        allowed_require_paths = Array(spec.require_paths)
+          .reject { |rqp| rqp.start_with?('.') }
+
+        allowed_require_paths.each(&block)
+      else
+        # If gemspec wasn't in the gem directory, let's just cheat.
+        yield 'lib'
+      end
+    end
+  end
+end

data/lib/wad/reporter.rb

@@ -0,0 +1,85 @@
+
+require 'wad/vendor/highlight'
+
+String.highlighter = Text::ANSIHighlighter.new
+
+module Wad
+
+  class Gig
+    def initialize text
+      @n = 0
+      @text = text
+
+      put
+    end
+
+    def put
+      a = %w(| / - \\)
+
+      ab(@text, a[@n % a.size])
+
+      inc
+    end
+
+    def done status
+      ab(@text, status)
+      puts
+    end
+
+    def ab a, b
+      printf("\r%s [%s]", a, b)
+    end
+
+    def inc
+      @n += 1
+    end
+  end
+
+  # Reports on progress. 
+  # 
+  class Reporter
+    attr_reader :gig
+
+    def report_emptying target
+      puts "Cleaning #{target}."
+    end
+
+    # @param target [Target] copy target
+    #
+    def report_copy_phase target
+      # printf "-> %s\n", target.to_s.green
+    end
+
+    # @param ghem [Gem] gem that copy phase is executed for
+    # @yield
+    #
+    def report_copy_for ghem
+      @gig = Gig.new(ghem.name.yellow)
+      @count = 0
+
+      yield
+      
+      @gig.done 'done'.green + " (#{@count} files copied)"
+    end
+
+    # @param gem_file [File] gem file that is being copied
+    # @param path [Pathname] target path
+    #
+    def report_copy_file gem_file, path
+      @count += 1
+      @gig.put
+    end
+
+    # @yield
+    # 
+    def report_bundle_install
+      printf("Performing a `%s`...\n", "bundle install".yellow)
+      yield
+      printf(" > %s\n", '...looks good!'.green)
+    end
+
+    def report_bundle_install_line line
+      puts " > #{line}"
+    end
+  end
+end

data/lib/wad/target.rb

@@ -0,0 +1,52 @@
+
+module Wad
+
+  # A target directory that will gem files through #copy. Also keeps track of 
+  # what files have already been written. 
+  #
+  class Target
+    attr_reader :path
+    attr_reader :postfix
+
+    attr_reader :existing
+    attr_reader :old_source
+    
+    attr_reader :reporter
+
+    def initialize path, postfix, reporter
+      @postfix = postfix
+      @path = path.join(postfix)
+      @existing = {}
+      @old_source = {}
+      @reporter = reporter
+
+      FileUtils.mkdir_p(path)
+    end
+
+    def to_s
+      postfix
+    end
+
+    def copy gem_file
+      key = gem_file.to.to_s
+      gem_name = gem_file.gem_name
+
+      # Try to detect multiple copies of one and the same gem file.
+      if existing.has_key?(key) && existing[key] != gem_name
+        name = existing[key]
+        old_path = old_source[key]
+
+        raise "Cannot copy #{gem_file.path} from #{gem_name}, already exists from #{name} (@#{old_path.to_s})."
+      else
+        existing[key] = gem_name
+        old_source[key] = gem_file.path
+
+        reporter.report_copy_file(gem_file, path)
+
+        dest = path.join(gem_file.to)
+        FileUtils.mkdir_p(dest.dirname)
+        FileUtils.cp(gem_file.path, dest) unless dest.file?
+      end
+    end
+  end
+end

data/lib/wad/vendor/highlight.rb

@@ -0,0 +1,298 @@
+#!/usr/bin/ruby -w
+
+# Our vendored copy of text-highlight (https://rubygems.org/gems/text-highlight)
+# version 1.0.2 by Jeff Pace.
+
+module Text
+
+  # Highlights text using either ANSI terminal codes, or HTML.
+
+  class Highlighter
+
+    VERSION = "1.0.2"
+
+    ATTRIBUTES = %w{
+      none
+      reset
+      bold
+      underscore
+      underline
+      blink
+      reverse
+      concealed
+      black
+      red
+      green
+      yellow
+      blue
+      magenta
+      cyan
+      white
+      on_black
+      on_red
+      on_green
+      on_yellow
+      on_blue
+      on_magenta
+      on_cyan
+      on_white
+    }
+
+    NONE = Object.new
+    HTML = Object.new
+    ANSI = Object.new
+
+    # Colorizes the given object. If a block is passed, its return value is used
+    # and the stream is reset. If a String is provided as the object, it is
+    # colorized and the stream is reset. Otherwise, only the code for the given
+    # color name is returned.
+    
+    def color(colorname, obj = self, &blk)
+      #                        ^^^^ this is the Module self
+      result = name_to_code(colorname)
+      if blk
+        result << blk.call
+        result << name_to_code("reset")
+      elsif obj.kind_of?(String)
+        result << obj
+        result << name_to_code("reset")
+      end
+      result
+    end
+
+    ATTRIBUTES.each do |attr|
+      code = <<-EODEF
+      def #{attr}(&blk)
+        color("#{attr}", &blk)
+      end
+
+      EODEF
+
+      eval code
+    end
+
+    # returns the code for the given color string, which is in the format:
+    # foreground* [on background]?
+    # 
+    # Note that the foreground and background sections can have modifiers
+    # (attributes).
+    # 
+    # Examples:
+    #     black
+    #     blue on white
+    #     bold green on yellow
+    #     underscore bold magenta on cyan
+    #     underscore red on cyan
+
+    def code(str)
+      fg, bg = str.split(/\s*\bon_?\s*/)
+      (fg ? foreground(fg) : "") + (bg ? background(bg) : "")
+    end
+
+    # Returns the code for the given background color(s).
+    def background(bgcolor)
+      name_to_code("on_" + bgcolor)
+    end
+
+    # Returns the code for the given foreground color(s).
+    def foreground(fgcolor)
+      fgcolor.split(/\s+/).collect { |fg| name_to_code(fg) }.join("")
+    end
+
+  end
+
+
+  # Highlights using HTML. Fonts are highlighted using <span> tags, not <font>.
+  # Also note that reverse is translated to white on black.
+  # According to http://www.w3.org/TR/REC-CSS2/syndata.html#value-def-color,
+  # valid color keywords are: aqua, black, blue, fuchsia, gray, green, lime,
+  # maroon, navy, olive, purple, red, silver, teal, white, and yellow.
+  # Thus, no magenta or cyan.
+
+  class HTMLHighlighter < Highlighter
+
+    def initialize
+      # we need to know what we're resetting from (bold, font, underlined ...)
+      @stack = []
+    end
+
+    # Returns the start tag for the given name.
+    
+    def start_style(name)
+      case name
+      when "reverse"
+        "<span style=\"color: white; background-color: black\">"
+      when /on_(\w+)/
+        "<span style=\"background-color: #{$1}\">"
+      else
+        "<span style=\"color: #{name}\">"
+      end
+    end
+
+    # Returns the end tag ("</span>").
+
+    def end_style
+      "</span>"
+    end
+
+    def color_value(cname)
+      case cname
+      when "cyan"
+        "#00FFFF"
+      when "magenta"
+        "#FF00FF"
+      else
+        cname
+      end
+    end
+
+    # Returns the code for the given name.
+
+    def name_to_code(name)
+      @stack << name
+
+      case name
+      when "none", "reset"
+        @stack.pop
+        str = ""
+        if @stack.length > 0
+          begin
+            prev = @stack.pop
+            case prev
+            when "bold"
+              str << "</b>"
+            when "underscore", "underline"
+              str << "</u>"
+            when "blink"
+              str << "</blink>"
+            when "concealed"
+              str << " -->"
+            else
+              str << end_style
+            end
+          end while @stack.length > 0
+        end
+        str
+      when "bold"
+        "<b>"
+      when "underscore", "underline"
+        "<u>"
+      when "blink"
+        "<blink>"
+      when "concealed"
+        "<!-- "
+      else
+        start_style(name)
+      end
+    end
+
+  end
+
+
+  # Highlights using ANSI escape sequences.
+
+  class ANSIHighlighter < Highlighter
+
+    @@ATTRIBUTES = Hash[
+      'none'       => '0', 
+      'reset'      => '0',
+      'bold'       => '1',
+      'underscore' => '4',
+      'underline'  => '4',
+      'blink'      => '5',
+      'reverse'    => '7',
+      'concealed'  => '8',
+      'black'      => '30',
+      'red'        => '31',
+      'green'      => '32',
+      'yellow'     => '33',
+      'blue'       => '34',
+      'magenta'    => '35',
+      'cyan'       => '36',
+      'white'      => '37',
+      'on_black'   => '40',
+      'on_red'     => '41',
+      'on_green'   => '42',
+      'on_yellow'  => '43',
+      'on_blue'    => '44',
+      'on_magenta' => '45',
+      'on_cyan'    => '46',
+      'on_white'   => '47',
+    ]
+
+    # Returns the escape sequence for the given name.
+
+    def name_to_code(nm)
+      "\e[#{@@ATTRIBUTES[nm]}m"
+    end
+
+  end
+
+  
+  # Does no highlighting.
+
+  class NonHighlighter < Highlighter
+
+    # Since the NonHighlighter does no highlighting, and thus its name, this
+    # returns an empty string.
+
+    def name_to_code(colorname)
+      ""
+    end
+
+  end
+
+
+  # An object that can be highlighted. This is used by the String class.
+
+  module Highlightable
+
+    # The highlighter for the class in which this module is included.
+
+    @@highlighter = NonHighlighter.new
+    
+    Text::Highlighter::ATTRIBUTES.each do |attr|
+      code = <<-EODEF
+      def #{attr}(&blk)
+        @@highlighter.color("#{attr}", self, &blk)
+      end
+
+      EODEF
+
+      eval code
+    end
+
+    alias negative reverse
+
+    # Sets the highlighter for this class. This can be either by type or by
+    # String.
+
+    def highlighter=(hl)
+      $VERBOSE = false
+      @@highlighter = case hl
+                      when Text::Highlighter
+                        hl
+                      when Text::Highlighter::NONE, "NONE", nil
+                        Text::NonHighlighter.new  unless @@highlighter.kind_of?(Text::NonHighlighter)
+                      when Text::Highlighter::HTML, "HTML"
+                        Text::HTMLHighlighter.new unless @@highlighter.kind_of?(Text::HTMLHighlighter)
+                      when Text::Highlighter::ANSI, "ANSI"
+                        Text::ANSIHighlighter.new unless @@highlighter.kind_of?(Text::ANSIHighlighter)
+                      else
+                        Text::NonHighlighter.new
+                      end
+    end
+
+  end
+
+  $HAVE_TEXT_HIGHLIGHT = true
+
+end
+
+
+# String is extended to support highlighting.
+
+class String
+  include Text::Highlightable
+  extend Text::Highlightable
+end

data/wad.gemspec

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+
+# Yes, we don't use generators and hoes for this. This is simple enough. 
+
+Gem::Specification.new do |s|
+  s.name = 'wad'
+  s.version = '0.2.0'
+
+  s.authors = ['Kaspar Schiess', 'Florian Hanke']
+  s.email = [
+    'kaspar.schiess@technologyastronauts.ch', 
+    'florian.hanke@technologyastronauts.ch']
+  s.extra_rdoc_files = ['README']
+
+  # Generate this manifest using 'git ls-tree -r --name-only master'
+  s.files = File.readlines('manifest.txt')
+    .map { |l| l.chomp } -
+      %w(.gitignore manifest.txt)
+  s.homepage = 'https://bitbucket.org/technologyastronauts/wad'
+  s.rdoc_options = ['--main', 'README']
+  s.require_paths = ['lib']
+
+  s.license = 'MIT'
+
+  s.summary = 
+  'After rubygems and bundler, let us take you full circle and go back to a 
+lib directory that contains all your libraries. Except now, it\'s per project. '
+
+  s.description = <<-EOD
+    Since we're all following very strict standards with regards to how our gems 
+    are constructed, we might as well pack all those gems back into a directory 
+    and use that directory in our load path. 
+
+    Once you do that, you'll discover that loading from all these paths and doing 
+    dependency resolution cost on every ruby invocation. On our machines, using 
+    wad saves us >500ms every time, on every call. 
+
+    Wad helps you with getting there: It vendors your Gemfile below `vendor/bundle`, 
+    then copies relevant source code to `vendor/lib`. All in one simple call. 
+  EOD
+
+  s.executables << 'wad'
+
+  s.add_runtime_dependency 'clamp', '~> 0.6'
+  s.add_runtime_dependency 'bundler', '> 0'
+  s.add_runtime_dependency 'mixlib-shellout', '~> 2.0'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: wad
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Kaspar Schiess
+- Florian Hanke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: mixlib-shellout
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: "    Since we're all following very strict standards with regards to
+  how our gems \n    are constructed, we might as well pack all those gems back into
+  a directory \n    and use that directory in our load path. \n\n    Once you do that,
+  you'll discover that loading from all these paths and doing \n    dependency resolution
+  cost on every ruby invocation. On our machines, using \n    wad saves us >500ms
+  every time, on every call. \n\n    Wad helps you with getting there: It vendors
+  your Gemfile below `vendor/bundle`, \n    then copies relevant source code to `vendor/lib`.
+  All in one simple call. \n"
+email:
+- kaspar.schiess@technologyastronauts.ch
+- florian.hanke@technologyastronauts.ch
+executables:
+- wad
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- Gemfile
+- LICENSE
+- README
+- bin/wad
+- lib/wad/bundle.rb
+- lib/wad/compiler.rb
+- lib/wad/file.rb
+- lib/wad/gem.rb
+- lib/wad/reporter.rb
+- lib/wad/target.rb
+- lib/wad/vendor/highlight.rb
+- wad.gemspec
+homepage: https://bitbucket.org/technologyastronauts/wad
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README
+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.2.2
+signing_key: 
+specification_version: 4
+summary: After rubygems and bundler, let us take you full circle and go back to a  lib
+  directory that contains all your libraries. Except now, it's per project.
+test_files: []
+has_rdoc: