invoca_gems 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6a2b87073e43fb10edbab421db7aa4c230ce7dda
+  data.tar.gz: bdc0d31c950d2b5eabe2cc4c591dc740160ff688
+SHA512:
+  metadata.gz: dbf0d9e1a6301fa42bb871355e582226fecc8b6c9321028390ab714ae5e5f986acd2a1edf486075b166c1efc95c5d47bf2665f1f50eac67f15cda8c4bc104d75
+  data.tar.gz: 940827af82abd909c66ebf1949e788567c946be8b24e2fb8c6366aa366d3c81df6b70bab3f21596c1a2479cff7e463d09acda431ab863876fbde1dfe9bdfb603

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea

data/.ruby_version

@@ -0,0 +1 @@
+2.1.2

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.2

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in invoca_gems.gemspec
+gemspec
+
+# These are used for testing.
+gem 'invoca-utils', '0.0.2',  git: 'git@github.com:Invoca/invoca-utils',              ref: 'c508647bc8adcba14e9cb86e03a6721af83d0195'
+
+gem 'test_source_gem', path: 'test/fixtures/test_source_gem'

data/Gemfile.lock

@@ -0,0 +1,43 @@
+GIT
+  remote: git@github.com:Invoca/invoca-utils
+  revision: c508647bc8adcba14e9cb86e03a6721af83d0195
+  ref: c508647bc8adcba14e9cb86e03a6721af83d0195
+  specs:
+    invoca-utils (0.0.2)
+
+PATH
+  remote: .
+  specs:
+    invoca_gems (0.1.0)
+
+PATH
+  remote: test/fixtures/test_source_gem
+  specs:
+    test_source_gem (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.1)
+    method_source (0.8.2)
+    minitest (5.8.4)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.5.0)
+    slop (3.6.0)
+    thor (0.19.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.8)
+  invoca-utils (= 0.0.2)!
+  invoca_gems!
+  minitest
+  pry
+  rake (~> 10.0)
+  test_source_gem!
+  thor

data/README.md

@@ -0,0 +1,81 @@
+# InvocaGems
+
+Makes working on the Invoca gems used by applications easier. 
+
+## Lighting Talk Intro
+Watch it here and count how many times I say "uuum"!  (Answer: lots)
+
+[Invoca Gem Lightning Talk](https://drive.google.com/a/invoca.com/file/d/0BzmD8uReM33rRi0ydTBiQlRmMzA/view)
+
+## Workflow
+The normal workflow would go something like this....
+
+### 1) Create a branch on the app-repo
+Start in the repo for the application that needs the changes.  (For example web or pnapi).  Create a branch for your story changes. 
+
+### 2) Open the gem for editing
+I am using invoca-metrics in this example.
+
+```
+bundle exec invoca_gem edit invoca-metrics
+```
+This will do the following:
+ * check out the invoca-metrics repo into invoca_gems/invoca_metrics.  
+ * create a new branch on that repo starting at the sha from the app-repo Gemfile.  The branch will use the same name as the app-repo.
+ * update the app-repo Gemfile to refer to the invoca metrics gem using a path.
+
+### 3) Make your gem changes
+At this point you can edit the invoca-metrics gem from the invoca_gems/invoca_metrics directory.  You can confirm your changes work on the app-repo by running tests there. 
+
+### 4) Save your gem changes
+When ready, save your changes to the invoca_metrics gem.
+
+```
+bundle exec invoca_gem save invoca-metrics --commit-message 'made some changes'
+```
+This can take a little while, so brace for it.  This will do the following:
+ * Commit your changes to the invoca_metrics gem and push them to github.
+ * Update the app-repo Gemfile for the new version and sha of the invoca_metrics gem.
+ * Update any other invoca gems that depend invoca_metrics.  For each of these gems it will:
+   * Pull down the gem and create a branch at the sha from the app-repo. 
+   * Update the gem version of invoca_metrics in the gemspec.
+   * Update the sha in the Gemfile for the dependent gem.
+   * Bundle install to pick up the changes.  (Takes a while.)
+   * Commit the changes and push to github.
+   * Update the app-repo gem to refer to the new sha.
+ * Bundle install the app-repo to pick up all the changes. 
+
+Whew.
+
+### 5) Create pull requests
+When ready you can view the changes and issue pull requests from github using the following command.
+
+```
+bundle exec invoca_gem show_changes
+```
+
+This will open a browser window showing all of the changed gems.  From there you can open pull requests and confirm build results.
+
+
+## Other commands
+
+Run the following to find available commands.
+```
+bundle exec invoca_gem
+```
+
+## Installation
+
+Add this line to your application's Gemfile as a development dependency:
+
+```ruby
+group :development do
+  gem 'invoca_gems'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+namespace :test do
+  Rake::TestTask.new do |t|
+    t.name = :unit
+    t.libs.push "lib"
+    t.test_files = FileList['test/unit/*_test.rb','test/unit/*/*_test.rb']
+    t.verbose = true
+  end
+
+end
+
+task :default => 'test:unit'
+
+

data/exe/invoca_gem

@@ -0,0 +1,3 @@
+require "invoca_gems"
+InvocaGems::Cli.start(ARGV)
+

data/invoca_gems.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'invoca_gems/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "invoca_gems"
+  spec.version       = InvocaGems::VERSION
+  spec.authors       = ["Bob Smith"]
+  spec.email         = ["bob@ringrevenue.com"]
+
+  spec.summary       = "help manage invoca_gems"
+  spec.description   = "manage invoca gems as if they were in-app gems"
+  spec.homepage      = "http://www.invoca.com"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "thor"
+end

data/lib/invoca_gems.rb

@@ -0,0 +1,18 @@
+require "pry"
+require "invoca_gems/version"
+require "invoca_gems/presenter"
+require "invoca_gems/shell_command"
+require "invoca_gems/bundler"
+require "invoca_gems/gem"
+require "invoca_gems/git_repo"
+require "invoca_gems/gemfile_line"
+require "invoca_gems/gemfile"
+require "invoca_gems/gemspec_line"
+require "invoca_gems/gemspec"
+
+require "invoca_gems/cli"
+
+module InvocaGems
+end
+
+

data/lib/invoca_gems/bundler.rb

@@ -0,0 +1,88 @@
+class InvocaGems::Bundler
+
+  GitSource = Struct.new(:name, :uri, :ref, :version)
+  def find_git_source(gem_name)
+    if source = definition.send(:sources).git_sources.find { |gs| source_name(gs) == gem_name }
+      GitSource.new(source_name(source), source.uri, source.ref, source.version)
+    end
+  end
+
+  PathSource = Struct.new(:name, :path, :version)
+  def find_path_source(gem_name)
+    if (spec = find_spec(gem_name)) && spec.source.respond_to?(:path)
+      PathSource.new(spec.name, spec.source.path, spec.version.to_s)
+    end
+  end
+
+  def dependants(gem_name)
+    dependant_hash[gem_name]
+  end
+
+  def dependencies_yuml_url
+    "http://yuml.me/diagram/class/#{URI::encode(invoca_dependencies.join(','))}"
+  end
+
+  def invoca_source_names
+    @invoca_source_names ||= definition.send(:sources).all_sources.map do |source|
+      if is_invoca_github_source?(source) || is_edited_source?(source)
+        source_name(source)
+      end
+    end.compact
+  end
+
+
+  private
+
+  def source_name(source)
+    # bundler replaces the name on the source with the github name, but the
+    # @name variable is still set with no other way to get to it.
+    source.instance_eval("@name") || source.name
+  end
+
+
+  def is_invoca_github_source?(source)
+    source.respond_to?(:uri) && source.uri =~ /Invoca/
+  end
+
+  def is_edited_source?(source)
+    source.respond_to?(:path) && source.path.to_s =~ /\Ainvoca_gems\//
+  end
+
+  def find_spec(gem_name)
+    definition.specs.select{ |s| s.name == gem_name }.first
+  end
+
+  def definition
+    @definition ||= Bundler.definition
+  end
+
+  def dependant_hash
+    unless @dependants
+      @dependants = {}
+      definition.specs.each do |spec|
+        spec.dependencies.each do |dependancy|
+          @dependants[dependancy.name] ||= []
+          @dependants[dependancy.name] << spec.name
+        end
+      end
+      @dependants
+    end
+  end
+
+
+  def invoca_dependencies
+    edges = []
+    definition.specs.each do |spec|
+      if invoca_source_names.include?(spec.name)
+        edges << "[#{spec.name}|#{spec.version}]"
+        spec.dependencies.each do |dep|
+          if invoca_source_names.include?(dep.name)
+            edges << "[#{spec.name}]->[#{dep.name}]"
+          end
+        end
+      end
+    end
+    edges.uniq
+  end
+end
+

data/lib/invoca_gems/cli.rb

@@ -0,0 +1,102 @@
+require "thor"
+require "open-uri"
+require 'bundler'
+
+class InvocaGems::Cli < Thor
+
+  desc "graph", "show graph of gem dependencies"
+  def graph
+    InvocaGems::Presenter.with_presenter do |presenter|
+      presenter.message "Generating Dependency Graph"
+      bw = InvocaGems::Bundler.new
+      `open #{bw.dependencies_yuml_url}`
+    end
+  end
+
+  desc "edit GEM", "configure a gem for local editing"
+  def edit(gem_name)
+    InvocaGems::Presenter.with_presenter do |presenter|
+      presenter.set_task "Configuring #{gem_name}"
+      gem = InvocaGems::Gem.new(gem_name, presenter)
+      gem.edit
+      presenter.set_subtask("done")
+      presenter.message("#{gem_name} is now available at #{gem.repo_directory}")
+    end
+  end
+
+  desc "save GEM", "save gem changes"
+  option :commit_message
+  def save(gem_name)
+    InvocaGems::Presenter.with_presenter do |presenter|
+      presenter.set_task "Saving changes to #{gem_name}"
+      gem = InvocaGems::Gem.new(gem_name, presenter)
+      gem.save(options[:commit_message])
+      presenter.message "Done"
+    end
+  end
+
+  desc "update GEM VERSION SHA", "updates a gem"
+  def update(gem_name, version, sha)
+    InvocaGems::Presenter.with_presenter do |presenter|
+      gem = InvocaGems::Gem.new(gem_name, presenter)
+      gem.update_version(version, sha)
+    end
+  end
+
+  desc "has_unsaved_changes GEM", "reports if the gem has changes"
+  def has_unsaved_changes(gem_name)
+    InvocaGems::Presenter.with_presenter do |presenter|
+      gem = InvocaGems::Gem.new(gem_name, presenter)
+      if gem.git_repo.unsaved_changes?
+        presenter.message "found unsaved changes"
+      else
+        presenter.message "no unsaved changes"
+      end
+    end
+  end
+
+  desc "show_changes", "show committed and pushed changes for the gem"
+  def show_changes
+    InvocaGems::Presenter.with_presenter do |presenter|
+      bw = InvocaGems::Bundler.new
+      bw.invoca_source_names.each do |gem_name|
+        presenter.set_task("#{gem_name}")
+        gem = InvocaGems::Gem.new(gem_name, presenter)
+        if gem.repo_exists? && gem.git_repo.branch_exists?(gem.local_branch_name)
+          # TODO - check for differences with master
+          url  = gem.uri.gsub("git@github.com:", "https://github.com/").gsub(".git","") + "/compare/#{gem.local_branch_name}"
+          `open #{url}`
+          presenter.set_subtask(url)
+        else
+          presenter.clear_task(keep: false)
+        end
+      end
+      presenter.message("done")
+    end
+  end
+
+
+  desc "list", "display the available invoca gems"
+  def list
+    InvocaGems::Presenter.with_presenter do |presenter|
+      presenter.silence do
+        format = "   %-30s  %10s  %-60s"
+        bw = InvocaGems::Bundler.new
+        puts
+        puts format % ["Name", "Version", "Status"]
+        puts format % ["="*30, "="*10, "="*60]
+        bw.invoca_source_names.each do |gem_name|
+          gem = InvocaGems::Gem.new(gem_name, presenter)
+          status =
+            if gem.path
+              presenter.using_mode( :green, "open for editing at #{gem.path}" )
+            else
+              "#{gem.sha[0..6]} for #{gem.uri}"
+            end
+          puts format % [gem.name, gem.version, status]
+        end
+        puts
+      end
+    end
+  end
+end

data/lib/invoca_gems/gem.rb

@@ -0,0 +1,225 @@
+class InvocaGems::Gem
+  WORKING_DIRECTORY = "invoca_gems"
+
+  include InvocaGems::ShellCommand
+
+  attr_reader :name, :uri, :sha, :version, :used_by, :dependants, :path, :branch, :presenter
+
+  def initialize(gem_name, presenter, defer_bundle: false)
+    @presenter = presenter
+    bundle_wrapper = InvocaGems::Bundler.new
+    try_load_from_git_source(bundle_wrapper, gem_name)
+    try_load_from_path_source(bundle_wrapper, gem_name)
+    @name or presenter.stop_with_message("Could not find gem #{gem_name}")
+    @dependants = bundle_wrapper.dependants(gem_name)
+    @defer_bundle = defer_bundle
+  end
+
+  def edit
+    configure_branch
+    update_gemfile_for_source
+    bundle_install_application
+  end
+
+  def save(commit_message=nil)
+    if git_repo.unsaved_changes?
+      if commit_message
+        commit_changes(commit_message)
+      else
+        presenter.stop_with_message "unsaved changes found in #{repo_directory}"
+      end
+    else
+      git_repo.push
+    end
+
+    update_gemfile_for_github(gemfile_path: "Gemfile",
+                              gem_name: name,
+                              gem_uri: uri,
+                              new_version: version,
+                              new_sha: git_repo.sha)
+
+    presenter.set_subtask("now at #{version} #{git_repo.sha[0..6]}")
+    update_dependencies(name, version, git_repo.sha)
+    bundle_install_application
+  end
+
+  def update_version(new_version, new_sha)
+    presenter.set_subtask "updating #{name} to #{new_version} #{new_sha}"
+    update_gemfile_for_github(
+      gemfile_path: "Gemfile",
+      gem_name: name,
+      gem_uri: uri,
+      new_version: new_version,
+      new_sha: new_sha)
+    update_dependencies(name, new_version, new_sha)
+    bundle_install_application
+  end
+
+  def update_dependencies(gem_to_update, version, sha)
+    if dependants
+      dependants.uniq.each do |dependant|
+        presenter.set_task "Updating #{dependant} for #{gem_to_update}"
+        gem = self.class.new(dependant, presenter, defer_bundle: true)
+        gem.edit
+
+        # Dependant gem update
+        gem.update_gemfile_for_github(
+          gemfile_path: gem.repo_directory + '/Gemfile',
+          gem_name: name,
+          gem_uri: uri,
+          new_version: version,
+          new_sha: sha)
+
+        # Project gem update
+        gem.update_gemfile_for_github(
+          gemfile_path: gem.repo_directory + '/Gemfile',
+          gem_name: name,
+          gem_uri: uri,
+          new_version: version,
+          new_sha: sha)
+
+        gem.update_gem_gemspec(gem.repo_directory + "/#{gem.name}.gemspec", gem_to_update, version)
+        gem.bundle_install_gem
+        gem.commit_changes("Update #{gem_to_update} to #{version} (#{sha[0..6]})")
+        gem.save # Will nest dependency upudate
+      end
+    end
+  end
+
+  def update_gem_gemspec(gemspec_path, gem_name, version)
+    presenter.set_subtask "updating #{gemspec_path} for #{gem_name}"
+    gemspec = InvocaGems::Gemspec.new(gemspec_path)
+    gemspec_gem = gemspec.find(gem_name)
+    gemspec_gem.update_version(version)
+    gemspec_gem.save!
+  end
+
+  def commit_changes(message)
+    git_repo.commit("#{local_branch_name} #{message}")
+    git_repo.push
+  end
+
+  def update_gemfile_for_github(gemfile_path:, gem_name:, gem_uri:, new_version:, new_sha:)
+    presenter.set_subtask "updating #{gemfile_path} for #{gem_name}"
+    gemfile = InvocaGems::Gemfile.new(gemfile_path)
+    gemfile_gem = gemfile.find(gem_name, allow_missing: true) || gemfile.append(gem_name)
+    gemfile_gem.update_as_github(new_version, gem_uri, new_sha)
+    gemfile_gem.save!
+  end
+
+
+  def repo_directory
+    WORKING_DIRECTORY + '/' + name
+  end
+
+  def repo_exists?
+    File.directory?(repo_directory)
+  end
+
+  def git_repo
+    create_working_directory
+    unless @git_repo
+      unless repo_exists?
+        presenter.set_subtask "creating #{repo_directory} from #{uri}"
+        InvocaGems::GitRepo.clone(WORKING_DIRECTORY, uri, name, presenter: presenter)
+      end
+      @git_repo = repo_for_path(repo_directory)
+      @git_repo.fetch
+    end
+    @git_repo
+  end
+
+  def repo_for_path(path)
+    InvocaGems::GitRepo.new(presenter, path)
+  end
+
+  def configure_branch
+    git_repo.unsaved_changes? and presenter.stop_with_message "Unsaved changes found in #{repo_directory}"
+    if !git_repo.branch_exists?(local_branch_name)
+      presenter.set_subtask "Creating branch #{local_branch_name}"
+      git_repo.create_branch_at(local_branch_name, sha)
+    end
+    presenter.set_subtask "Using branch #{local_branch_name}"
+    git_repo.checkout_branch(local_branch_name)
+
+    if git_repo.sha != sha
+      presenter.stop_with_message "Commited work not found in gem, use -- mumble mumble to fix."
+    end
+  end
+
+  def update_gemfile_for_source
+    gemfile = InvocaGems::Gemfile.new('Gemfile')
+    gemfile_gem = gemfile.find(name)
+    gemfile_gem.update_as_path(repo_directory)
+    gemfile_gem.save!
+  end
+
+  def local_branch_name
+    @local_branch_name ||= repo_for_path('.').branch
+  end
+
+  def try_load_from_git_source(bundle_wrapper, gem_name)
+    if result = bundle_wrapper.find_git_source(gem_name)
+      @name    = result.name
+      @uri     = result.uri
+      @version = result.version
+      @sha     = result.ref
+    end
+  end
+
+  def try_load_from_path_source(bundle_wrapper, gem_name)
+    if !@name && result = bundle_wrapper.find_path_source(gem_name)
+      @name = result.name
+      @path = result.path
+      @version = result.version
+      get_git_statistics_from_path(path)
+    end
+  end
+
+  def get_git_statistics_from_path(path)
+    repo = repo_for_path(path)
+    @uri = repo.uri
+    @sha = repo.sha
+    @branch = repo.branch
+  end
+
+  def configure_appilication
+    unless @application_configured
+      create_working_directory
+      @application_configured = true
+    end
+  end
+
+  def create_working_directory
+    if File.read(".gitignore") !~ /#{WORKING_DIRECTORY}/m
+      presenter.set_subtask "updating .gitignore"
+      File.open(".gitignore","a") { |f| f.write("# Invoca Gem support\n#{WORKING_DIRECTORY}/**\n") }
+    end
+
+    if !File.directory?(WORKING_DIRECTORY)
+      presenter.set_subtask "creating #{WORKING_DIRECTORY}"
+      Dir.mkdir(WORKING_DIRECTORY)
+    end
+  end
+
+  def bundle_install_application
+    unless @defer_bundle
+      without_ruby_options do
+        shell_command(command: "bundle install --quiet", presenter: presenter)
+      end
+    end
+  end
+
+  def bundle_install_gem
+    without_ruby_options do
+      shell_command(command: "bundle install --quiet", path: repo_directory, presenter: presenter)
+    end
+  end
+
+  def without_ruby_options
+    old_opt = ENV.delete("RUBYOPT")
+    yield
+  ensure
+    ENV["RUBYOPT"] = old_opt
+  end
+end

data/lib/invoca_gems/gemfile.rb

@@ -0,0 +1,34 @@
+class InvocaGems::Gemfile
+  def initialize(path)
+    @path = path
+    @lines = File.readlines(path).map(&:chomp)
+  end
+
+  def find(gem_name, allow_missing: false)
+    if index = @lines.find_index { |l| l =~ /\A\s*gem\s+.*[\'\"]#{gem_name}[\'\"]/ }
+      InvocaGems::GemfileLine.new(self, @lines[index], index)
+    else
+      allow_missing or InvocaGems::Presenter.stop_with_message "could not find gem #{gem_name}"
+      nil
+    end
+  end
+
+  def append(gem_name)
+    InvocaGems::GemfileLine.new(self, "gem '#{gem_name}'", -1)
+  end
+
+  def save!(gemspec)
+    update_gemspec(gemspec)
+    File.open(@path, "w") { |f| f.write(@lines.join("\n") + "\n") }
+  end
+
+  private
+
+  def update_gemspec(gemspec)
+    if gemspec.index == -1
+      @lines << gemspec.line
+    else
+      @lines = @lines[0, gemspec.index] + [gemspec.line] + @lines[gemspec.index+1..-1]
+    end
+  end
+end

data/lib/invoca_gems/gemfile_line.rb

@@ -0,0 +1,47 @@
+class InvocaGems::GemfileLine
+  attr_reader :gemfile, :line, :index
+  attr_reader :gem_name, :gem_version, :gem_ref, :gem_git, :gem_github, :gem_options, :gem_options
+
+  def initialize(gemfile, line, index)
+    @gemfile = gemfile
+    @line = line
+    @index = index
+    @prefix = @line.match(/\A(\s*)gem/)[1]
+
+    instance_eval(line)
+  end
+
+  def save!
+    gemfile.save!(self)
+  end
+
+  def gem(name, *args)
+    @gem_name    = name
+    @gem_options = args.last.is_a?(Hash) ? args.pop.dup : {}
+    @gem_version = args.first || ">= 0"
+    @gem_branch  = @gem_options[:branch] || 'master'
+    @gem_ref     = @gem_options.delete(:ref)
+    @gem_git     = @gem_options.delete(:git)
+    @gem_github  = @gem_options.delete(:github)
+  end
+
+  def update_as_path(path)
+    @line = [
+      "#{@prefix}gem ",
+      "'#{gem_name}',".ljust(24),
+      " path: '#{path}'"
+    ].join('')
+  end
+
+  # TODO - Perfer branch before ref.
+  # TODO - handle local branch...
+  def update_as_github(gem_version, uri, sha)
+    @line = [
+      "#{@prefix}gem ",
+      "'#{gem_name}',".ljust(24),
+      " '#{gem_version}', ".ljust(11),
+      "git: '#{uri}',".ljust(56),
+      "ref: '#{sha}'"
+    ].join('')
+  end
+end

data/lib/invoca_gems/gemspec.rb

@@ -0,0 +1,22 @@
+class InvocaGems::Gemspec
+  def initialize(path)
+    @path = path
+    @lines = File.readlines(path).map(&:chomp)
+  end
+
+  def find(gem_name)
+    index = @lines.find_index { |l| l =~ /\A\s*\S+\s+[\'\"]#{gem_name}[\'\"]/ } or InvocaGems::Presenter.stop_with_message "could not find gem #{gem_name} in #{@path}"
+    InvocaGems::GemspecLine.new(self, gem_name, @lines[index], index)
+  end
+
+  def save!(gemspec)
+    update_gemspec(gemspec)
+    File.open(@path, "w") { |f| f.write(@lines.join("\n") + "\n") }
+  end
+
+  private
+
+  def update_gemspec(gemspec)
+    @lines = @lines[0, gemspec.index] + [gemspec.line] + @lines[gemspec.index+1..-1]
+  end
+end

data/lib/invoca_gems/gemspec_line.rb

@@ -0,0 +1,19 @@
+class InvocaGems::GemspecLine
+  attr_reader :gemspec, :gem_name, :line, :index, :prefix
+
+  def initialize(gemspec, gem_name, line, index)
+    @gemspec = gemspec
+    @gem_name = gem_name
+    @line = line
+    @index = index
+    @prefix = @line.match(/\A(\s*\S+\s+)[\'\"]/)[1]
+  end
+
+  def save!
+    gemspec.save!(self)
+  end
+
+  def update_version(new_version)
+    @line = "#{@prefix}'#{gem_name}', '#{new_version}'"
+  end
+end

data/lib/invoca_gems/git_repo.rb

@@ -0,0 +1,80 @@
+require 'shellwords'
+require 'pathname'
+
+class InvocaGems::GitRepo
+  # Encapsulates running git commands in a given directory
+
+  include InvocaGems::ShellCommand
+  attr_accessor :presenter
+
+  def initialize(presenter, repo_root = nil)
+    @presenter = presenter
+    @repo_root = Pathname.new(repo_root ||  Dir.pwd)
+  end
+
+  def branch
+    git_cmd('rev-parse --abbrev-ref HEAD')
+  end
+
+  def sha
+    git_cmd("rev-parse --verify HEAD")
+  end
+
+  def uri
+    git_cmd("config --get remote.origin.url")
+  end
+
+  def fetch
+    git_cmd("fetch")
+  end
+
+  def commit(message)
+    git_cmd("add -A")
+    git_cmd("commit -m #{Shellwords.escape(message)}")
+  end
+
+  def is_ancestor_commit?(earlier_sha, current_sha)
+    git_cmd("merge-base --is-ancestor #{earlier_sha} #{current_sha}", raise_errors: false)
+  end
+
+
+  def branch_exists?(branch_name)
+    branch_name_escaped = Regexp.escape(branch_name)
+    if result = git_cmd("branch -a")
+      result.split("\n").any? do |branch_line|
+        branch_line =~ / #{branch_name_escaped}\z/ || branch_line =~ / remotes\/origin\/#{branch_name_escaped}\z/
+      end
+    end
+  end
+
+  def checkout_branch(branch_name)
+    git_cmd("checkout #{branch_name}")
+  end
+
+
+  def self.clone(root_directory, uri, directory_name, presenter:)
+    git_cmd(root_directory, "clone #{uri} #{directory_name}", presenter: presenter)
+  end
+
+  def unsaved_changes?
+    !git_cmd("diff --quiet", raise_errors: false) || !git_cmd("diff --quiet --cached", raise_errors: false)
+  end
+
+  def create_branch_at(branch_name, sha)
+    git_cmd("branch #{branch_name} #{sha}")
+  end
+
+  def push
+    git_cmd("push -u origin #{branch}")
+  end
+
+
+  def self.git_cmd(path, str, raise_errors: true, presenter: )
+    shell_command(command: "/usr/bin/git #{str}", path: path, raise_errors: raise_errors, presenter: presenter)
+  end
+
+  def git_cmd(str, raise_errors: true)
+    self.class.git_cmd(@repo_root, str, raise_errors: raise_errors, presenter: presenter)
+  end
+
+end

data/lib/invoca_gems/presenter.rb

@@ -0,0 +1,118 @@
+class InvocaGems::Presenter
+  def set_task(message)
+    clear_task
+    @task = using_mode(:green, message)
+    set_subtask('')
+  end
+
+  def clear_task(keep: true)
+    if @task
+      if keep
+        @new_line_needed = false
+        puts
+      else
+        print reset_line
+        @new_line_needed = false
+      end
+      @task = nil
+    end
+  end
+
+  def message(message)
+    puts using_mode(:green, message)
+  end
+
+  def warning(message)
+    puts using_mode(:yellow, "warning: #{message}")
+  end
+
+  def error(message)
+    puts using_mode(:red, "error: #{message}")
+  end
+
+  def set_subtask(message)
+    print "#{reset_line}#{@task}: #{message}"
+  end
+
+  def reset_line
+    "\r\e[K"
+  end
+
+  def puts(*args)
+    unless @silent
+      if @new_line_needed
+        super()
+        @new_line_needed = false
+      end
+      super
+    end
+  end
+
+  def print(*args)
+    unless @silent
+      @new_line_needed = true
+      super
+    end
+  end
+
+  def silence
+    @silent = true
+    yield
+  ensure
+    @silent = false
+  end
+
+  def set_mode(codes)
+    "\e[#{[codes].flatten.map{ |c| COLOR_CODES[c].to_s }.join(";")}m"
+  end
+
+  def using_mode(codes, message)
+    set_mode(codes) + message + set_mode(:clear)
+  end
+
+  class StopWithMessage < StandardError; end
+  def stop_with_message(message)
+    raise StopWithMessage, message
+  end
+
+  def self.stop_with_message(message)
+    raise StopWithMessage, message
+  end
+
+
+  def self.with_presenter
+    presenter = new
+    begin
+      yield presenter
+    rescue StopWithMessage => ex
+      presenter.error(ex.message)
+    end
+  end
+
+  COLOR_CODES = {
+    clear: 0,
+    bright: 1,
+    underline: 4,
+    blink: 5,
+    swap: 7,
+    hide: 8,
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    white: 37,
+    default: 39,
+    black_background: 40,
+    red_background: 41,
+    blue_background: 40,
+    green_background: 42,
+    blue_background: 44,
+    magenta_background: 45,
+    cyan_background: 46,
+    white_background: 47,
+    default_background: 49
+  }
+
+end

data/lib/invoca_gems/shell_command.rb

@@ -0,0 +1,22 @@
+require 'open3'
+
+module InvocaGems::ShellCommand
+  def self.included(klass)
+    klass.send(:extend, InvocaGems::ShellCommand)
+  end
+
+  # Returns the command output, stripped
+  # Or nil if command failed
+  Response = Struct.new(:stdout, :stderr, :code)
+  def shell_command(command:, path: '.', presenter:, raise_errors: true)
+    presenter.set_subtask "cd #{path}; #{command}"
+    r = Response.new(*Open3.capture3("cd #{path}; #{command}"))
+    if r.code && r.code.success?
+      r.stdout.strip
+    else
+      if raise_errors
+        presenter.stop_with_message "cd #{path}; #{command}: returned error #{r.code.exitstatus}: #{r.stdout}\n#{r.stderr}"
+      end
+    end
+  end
+end

data/lib/invoca_gems/version.rb

@@ -0,0 +1,3 @@
+module InvocaGems
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: invoca_gems
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bob Smith
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: manage invoca gems as if they were in-app gems
+email:
+- bob@ringrevenue.com
+executables:
+- invoca_gem
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby_version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- exe/invoca_gem
+- invoca_gems.gemspec
+- lib/invoca_gems.rb
+- lib/invoca_gems/bundler.rb
+- lib/invoca_gems/cli.rb
+- lib/invoca_gems/gem.rb
+- lib/invoca_gems/gemfile.rb
+- lib/invoca_gems/gemfile_line.rb
+- lib/invoca_gems/gemspec.rb
+- lib/invoca_gems/gemspec_line.rb
+- lib/invoca_gems/git_repo.rb
+- lib/invoca_gems/presenter.rb
+- lib/invoca_gems/shell_command.rb
+- lib/invoca_gems/version.rb
+homepage: http://www.invoca.com
+licenses: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: help manage invoca_gems
+test_files: []