git-semaphore 0.0.2

data/features/git_config.feature

@@ -0,0 +1,11 @@
+Feature: Configuration, Configuration, Configuration
+
+  Scenario: run the main script with tokens set in the git configuration
+
+    Given a git repo in directory "blegga" with config:
+        | semaphore.authtoken    | foo   |
+        | semaphore.projecttoken | bar   |
+    When I run `git-semaphore --git-config` in "blegga" directory
+    Then the exit status should be 0
+     And the output should match /git config --local --replace-all semaphore.authtoken "foo"/
+     And the output should match /git config --local --replace-all semaphore.projecttoken "bar"/

data/features/help_and_version.feature

@@ -0,0 +1,31 @@
+Feature: Help Me I've Got Versionitis
+
+  Scenario: get help for the main script
+
+    When I get help for "git-semaphore"
+    Then the exit status should be 0
+     And the banner should be present
+     And the banner should include the version
+     And the banner should document that this app takes options
+     And the following options should be documented:
+       | --version, -v:       |
+       | --help, -h:          |
+       | --working-dir, -w:   |
+       | --project-name, -p:  |
+       | --branch-name, -b:   |
+       | --check-auth, -x:    |
+       | --check-project, -y: |
+       | --check-branch, -z:  |
+       | --env-config, -e:    |
+       | --git-config, -g:    |
+       | --projects, -r:      |
+       | --branches, -a:      |
+       | --status, -s:        |
+
+  Scenario: get the version of the main script
+
+    When I get the version of "git-semaphore"
+    Then the exit status should be 0
+     And the output should include the version
+     And the output should include the app name
+     And the output should include a copyright notice

data/features/semaphore_app_api.feature

@@ -0,0 +1,22 @@
+Feature: Show Me What You've Got
+
+  @vcr_api_projects
+  Scenario: user's projects
+
+    Given I am an authenticated user on semaphoreapp.com
+      And get the list of all my projects via their API
+     Then the JSON should be an array
+
+  @vcr_api_branches
+  Scenario: project's branches
+
+    Given I am an authenticated user on semaphoreapp.com
+      And get the list of all the branches for one of my projects via their API
+     Then the JSON should be an array
+
+  @vcr_api_status
+  Scenario: branch status
+
+    Given I am an authenticated user on semaphoreapp.com
+      And get the build status of one of the branches for one of my projects via their API
+     Then the JSON should be a hash

data/features/semaphore_app_config.feature

@@ -0,0 +1,37 @@
+Feature: Configuration, Configuration, Configuration
+
+  Scenario: create an app instance inside a git repo without config
+
+    Given a git repo in directory "blegga"
+      And the "SEMAPHORE_AUTH_TOKEN" env variable is not set
+      And the "SEMAPHORE_PROJECT_TOKEN" env variable is not set
+     Then the application doesn't have an auth token
+      And the application doesn't have a project token
+
+  Scenario: create an app instance inside a git repo with config
+
+    Given a git repo in directory "blegga" with config:
+        | semaphore.authtoken     | foo    |
+        | semaphore.projecttoken  | bar    |
+     Then the application uses "foo" as the auth token
+      And the application uses "bar" as the project token
+
+  Scenario: create an app instance inside a git repo without config
+
+    Given a git repo in directory "blegga"
+      And a runtime environment with config:
+        | SEMAPHORE_AUTH_TOKEN    | foofoo |
+        | SEMAPHORE_PROJECT_TOKEN | barbar |
+     Then the application uses "foofoo" as the auth token
+      And the application uses "barbar" as the project token
+
+  Scenario: create an app instance inside a git repo with config
+
+    Given a git repo in directory "blegga" with config:
+        | semaphore.authtoken     | foo    |
+        | semaphore.projecttoken  | bar    |
+      And a runtime environment with config:
+        | SEMAPHORE_AUTH_TOKEN    | foofoo |
+        | SEMAPHORE_PROJECT_TOKEN | barbar |
+     Then the application uses "foo" as the auth token
+      And the application uses "bar" as the project token

data/features/semaphore_auth_token.feature

@@ -0,0 +1,32 @@
+Feature: How to Overcome Your Fear of Authority
+
+  Scenario: run the main script with the auth token set in the env
+
+    Given the "SEMAPHORE_AUTH_TOKEN" env variable is set
+     When I run `git-semaphore --check-auth` in a git working dir
+     Then the exit status should be 0
+      And the stderr should contain exactly:
+        """
+        """
+
+  Scenario: run the main script with the auth token set in git config
+
+    Given "semaphore.authtoken" git config is set for git repo "blegga"
+     When I run `git-semaphore --check-auth` in "blegga" directory
+     Then the exit status should be 0
+      And the stderr should contain exactly:
+        """
+        """
+
+  Scenario: run the main script with the auth token not set in the env
+
+    Given the "SEMAPHORE_AUTH_TOKEN" env variable is not set
+      And "semaphore.authtoken" git config is not set for git repo "blegga"
+     When I run `git-semaphore --check-auth` in "blegga" directory
+     Then the exit status should be 255
+      And the stderr should contain exactly:
+        """
+        Please set - and export - the SEMAPHORE_AUTH_TOKEN env variable
+        Alternatively, set semaphore.authtoken in your local git config
+
+        """

data/features/semaphore_project_token.feature

@@ -0,0 +1,32 @@
+Feature: Always Carry Identification Wherever You Go
+
+  Scenario: run the main script with the project token set in the env
+
+    Given the "SEMAPHORE_PROJECT_TOKEN" env variable is set
+     When I run `git-semaphore --check-project` in a git working dir
+     Then the exit status should be 0
+      And the stderr should contain exactly:
+        """
+        """
+
+  Scenario: run the main script with the project token set in git config
+
+    Given "semaphore.projecttoken" git config is set for git repo "blegga"
+     When I run `git-semaphore --check-project` in "blegga" directory
+     Then the exit status should be 0
+      And the stderr should contain exactly:
+        """
+        """
+
+  Scenario: run the main script with the project token not set in the env
+
+    Given the "SEMAPHORE_PROJECT_TOKEN" env variable is not set
+      And "semaphore.projecttoken" git config is not set for git repo "blegga"
+     When I run `git-semaphore --check-project` in "blegga" directory
+     Then the exit status should be 255
+      And the stderr should contain exactly:
+        """
+        Please set - and export - the SEMAPHORE_PROJECT_TOKEN env variable
+        Alternatively, set semaphore.projecttoken in your local git config
+
+        """

data/features/step_definitions/git-semaphore_steps.rb

@@ -0,0 +1,121 @@
+#
+# Steps that interact with ENV
+#
+
+Before do
+ set_env('SEMAPHORE_AUTH_TOKEN', nil)
+ set_env('SEMAPHORE_PROJECT_TOKEN', nil)
+end
+
+After do
+  restore_env
+end
+
+Given /^the "([A-Z_]+)" env variable is set(?: to "([^"]*)")?$/ do |key, value|
+  set_env(key, value || 'blegga')
+end
+
+Given /^the "([A-Z_]+)" env variable is not set$/ do |key|
+  set_env(key, nil)
+end
+
+Given /^a runtime environment with config:$/ do |config_table|
+  config_table.rows_hash.each do |key, value|
+    set_env(key, value)
+  end
+end
+
+#
+# Steps that interact with git
+#
+
+Given /^a git repo in directory "([^"]*)"$/ do |project_name|
+  @pwd = File.join(current_dir, project_name)
+  @repo = Grit::Repo.init(@pwd)
+end
+
+Given /^a git repo in directory "([^"]*)" with config:$/ do |project_name, config_table|
+  step %(a git repo in directory "#{project_name}")
+  config_table.rows_hash.each do |key, value|
+    @repo.config[key] = value
+  end
+end
+
+Given /^"([^"]*)" git config is (not set|set) for git repo "([^"]*)"$/ do |key, is_or_isnt_set, project_name|
+  step %(a git repo in directory "#{project_name}")
+  @repo.config[key] = 'blegga' unless is_or_isnt_set == "not set"
+end
+
+#
+# Steps that interact with Dir.pwd
+#
+
+When /^I run `([^`]*)` in a git working dir$/ do |cmd|
+  working_dir = "foo/bar/qux_blegga"
+  step %(a git repo in directory "#{working_dir}")
+  step %(I run `#{cmd}` in "#{working_dir}" directory)
+end
+
+When /^I run `([^`]*)` in "([^"]*)" directory$/ do |cmd, working_dir|
+  step %(a directory named "#{working_dir}")
+  cd working_dir
+  step %(I run `#{cmd}`)
+  @dirs = ['tmp', 'aruba'] # reset Aruba::API.current_dir
+end
+
+#
+# Methodane/Aruba "extensions"/"customizations"
+#
+
+When /^I get the version of "([^"]*)"$/ do |app_name|
+  @app_name = app_name
+  step %(I run `#{app_name} --version`)
+end
+
+Then /^the output should include the version$/ do
+  step %(the output should match /v\\d+\\.\\d+\\.\\d+/)
+end
+
+Then /^the output should include the app name$/ do
+  step %(the output should match /#{Regexp.escape(@app_name)}/)
+end
+
+Then /^the output should include a copyright notice$/ do
+  step %(the output should match /Copyright \\(c\\) [\\d]{4} [[\\w]+]+/)
+end
+
+#
+# Steps that check config expectations
+#
+
+# Then /^the application uses "([^"]+)" as the git auth token$/ do |auth_token|
+#   (@app || Git::Semaphore::App.new(@repo, ENV)).git_auth_token.should eq auth_token
+# end
+
+# Then /^the application uses "([^"]+)" as the git project token$/ do |project_token|
+#   (@app || Git::Semaphore::App.new(@repo, ENV)).git_project_token.should eq project_token
+# end
+
+# Then /^the application uses "([^"]+)" as the env auth token$/ do |auth_token|
+#   (@app || Git::Semaphore::App.new(@repo, ENV)).env_auth_token.should eq auth_token
+# end
+
+# Then /^the application uses "([^"]+)" as the env project token$/ do |project_token|
+#   (@app || Git::Semaphore::App.new(@repo, ENV)).env_project_token.should eq project_token
+# end
+
+Then /^the application doesn't have an auth token$/ do
+  (@app || Git::Semaphore::App.new(@pwd, ENV)).auth_token.should be_nil
+end
+
+Then /^the application doesn't have a project token$/ do
+  (@app || Git::Semaphore::App.new(@pwd, ENV)).project_token.should be_nil
+end
+
+Then /^the application uses "([^"]+)" as the auth token$/ do |auth_token|
+  (@app || Git::Semaphore::App.new(@pwd, ENV)).auth_token.should eq auth_token
+end
+
+Then /^the application uses "([^"]+)" as the project token$/ do |project_token|
+  (@app || Git::Semaphore::App.new(@pwd, ENV)).project_token.should eq project_token
+end

data/features/step_definitions/vcr_semaphore_steps.rb

@@ -0,0 +1,21 @@
+Given /^I am an authenticated user on semaphoreapp\.com$/ do
+  @auth_token = SEMAPHORE_TEST_TOKEN
+  @project = '649e584dc507ca4b73e1374d3125ef0b567a949c'
+  @branch = '89'
+end
+
+Given /^get the list of all my projects via their API$/ do
+  @response = Git::Semaphore::Api.get_response Git::Semaphore::Api.projects_uri(@auth_token)
+end
+
+Given /^get the list of all the branches for one of my projects via their API$/ do
+  @response = Git::Semaphore::Api.get_response Git::Semaphore::Api.branches_uri(@project, @auth_token)
+end
+
+Given /^get the build status of one of the branches for one of my projects via their API$/ do
+  @response = Git::Semaphore::Api.get_response Git::Semaphore::Api.status_uri(@project, @branch, @auth_token)
+end
+
+def last_json
+  @response.body
+end

data/features/support/env.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
+
+require 'git-semaphore'
+
+require 'aruba/cucumber'
+require 'methadone/cucumber'
+require 'cucumber-pride'
+require "json_spec/cucumber"

data/features/support/semaphoreapp.rb

@@ -0,0 +1,2 @@
+# http://docs.semaphoreapp.com/api
+SEMAPHORE_TEST_TOKEN='Yds3w6o26FLfJTnVK2y9'

data/features/support/vcr.rb

@@ -0,0 +1,13 @@
+require 'vcr'
+
+VCR.configure do |c|
+  c.hook_into :webmock # or :fakeweb
+  c.cassette_library_dir = 'features/cassettes'
+  c.debug_logger = File.open('vcr_debug.log', 'w')
+end
+
+VCR.cucumber_tags do |t|
+  t.tag '@vcr_api_projects'
+  t.tag '@vcr_api_branches'
+  t.tag '@vcr_api_status'
+end

data/features/working_directory.feature

@@ -0,0 +1,22 @@
+Feature: It's Where You Can Find Me
+
+  Scenario: print out the working directory
+
+    Given a git repo in directory "foo/bar/qux_blegga"
+     When I run `git-semaphore --working-dir` in "foo/bar/qux_blegga" directory
+     Then the exit status should be 0
+      And the output should contain "foo/bar"
+
+  Scenario: print out the project name
+
+    Given a git repo in directory "foo/bar/qux_blegga"
+     When I run `git-semaphore --project-name` in "foo/bar/qux_blegga" directory
+     Then the exit status should be 0
+      And the output should contain "qux_blegga"
+
+  Scenario: print out the branch name
+
+    Given a git repo in directory "foo/bar/qux_blegga"
+     When I run `git-semaphore --branch-name` in "foo/bar/qux_blegga" directory
+     Then the exit status should be 0
+      And the output should contain "master"

data/git-semaphore.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'git-semaphore/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "git-semaphore"
+  gem.version       = Git::Semaphore::VERSION
+  gem.authors       = ["Peter Vandenberk"]
+  gem.email         = ["pvandenberk@mac.com"]
+  gem.description   = ["git integration with https://semaphoreapp.com"]
+  gem.summary       = ["git integration with https://semaphoreapp.com"]
+  gem.homepage      = "https://github.com/pvdb/git-semaphore"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency('grit')
+  gem.add_dependency('trollop')
+
+  gem.add_development_dependency('pry')
+  gem.add_development_dependency('rake')
+  gem.add_development_dependency('awesome_print')
+  gem.add_development_dependency('cucumber')
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('aruba')
+  gem.add_development_dependency('methadone')
+  gem.add_development_dependency('guard-rspec')
+  gem.add_development_dependency('guard-cucumber')
+  gem.add_development_dependency('rb-fsevent')
+  gem.add_development_dependency('growl')
+  gem.add_development_dependency('rspec-pride')
+  gem.add_development_dependency('cucumber-pride')
+  gem.add_development_dependency('vcr')
+  gem.add_development_dependency('webmock')
+  gem.add_development_dependency('jazor')
+  gem.add_development_dependency('json_spec')
+end

data/lib/git-semaphore/api.rb

@@ -0,0 +1,55 @@
+require 'uri'
+require 'net/http'
+
+module Git
+  module Semaphore
+    class Api
+
+      # http://docs.semaphoreapp.com/api
+
+      SEMAPHORE_API_HOST = 'semaphoreapp.com'
+      SEMAPHORE_API_URI = '/api/v1'
+
+      def self.projects_uri auth_token
+        URI::HTTPS.build(
+          :host => SEMAPHORE_API_HOST,
+          :path => File.join(SEMAPHORE_API_URI, 'projects'),
+          :query => "auth_token=#{auth_token}"
+        )
+      end
+
+      def self.branches_uri project_hash_id, auth_token
+        URI::HTTPS.build(
+          :host => SEMAPHORE_API_HOST,
+          :path => File.join(SEMAPHORE_API_URI, 'projects', project_hash_id, 'branches'),
+          :query => "auth_token=#{auth_token}"
+        )
+      end
+
+      def self.status_uri project_hash_id, branch_id, auth_token
+        URI::HTTPS.build(
+          :host => SEMAPHORE_API_HOST,
+          :path => File.join(SEMAPHORE_API_URI, 'projects', project_hash_id, branch_id, 'status'),
+          :query => "auth_token=#{auth_token}"
+        )
+      end
+
+      def self.history_uri project_hash_id, branch_id, auth_token
+        URI::HTTPS.build(
+          :host => SEMAPHORE_API_HOST,
+          :path => File.join(SEMAPHORE_API_URI, 'projects', project_hash_id, branch_id),
+          :query => "auth_token=#{auth_token}"
+        )
+      end
+
+      # helper functions
+
+      def self.get_response uri
+        ::Net::HTTP.start(uri.host, uri.port, :use_ssl => (uri.scheme == 'https'), :verify_mode => OpenSSL::SSL::VERIFY_NONE) do |net_http|
+          net_http.get(uri.request_uri)
+        end
+      end
+
+    end
+  end
+end

data/lib/git-semaphore/app.rb

@@ -0,0 +1,118 @@
+require 'json'
+
+class Git::Semaphore::App
+
+  attr_accessor :env_auth_token
+  attr_accessor :env_project_token
+
+  attr_accessor :working_dir
+  attr_writer   :branch_name
+  attr_accessor :commit
+  attr_writer   :project_name
+
+  def initialize working_dir, config = ENV
+    self.working_dir = working_dir
+
+    self.project_name = config['PROJECT']
+    self.branch_name = config['BRANCH']
+    self.commit = config['COMMIT']
+
+    self.env_auth_token = config['SEMAPHORE_AUTH_TOKEN']
+    self.env_project_token = config['SEMAPHORE_PROJECT_TOKEN']
+  end
+
+  def git_auth_token
+    git_repo.config['semaphore.authtoken']
+  end
+
+  def git_project_token
+    git_repo.config['semaphore.projecttoken']
+  end
+
+  def git_repo
+    @git_repo ||= Grit::Repo.new(working_dir)
+  end
+
+  def validate
+    '' != branch_name.to_s.gsub(/\s+/, '')
+  rescue
+    false
+  end
+
+  def auth_token
+    git_auth_token || env_auth_token
+  end
+
+  def project_token
+    git_project_token || env_project_token
+  end
+
+  def project_name
+    return @project_name unless @project_name.nil?
+    File.basename working_dir
+  end
+
+  def branch_name
+    return @branch_name unless @branch_name.nil?
+    git_repo.head.name
+  end
+
+  def projects
+    @projects ||= begin
+      uri = Git::Semaphore::Api.projects_uri(auth_token)
+      Git::Semaphore::Api.get_response(uri).body
+    end
+  end
+
+  def branches
+    @branches ||= begin
+      uri = Git::Semaphore::Api.branches_uri(project_hash_id, auth_token)
+      Git::Semaphore::Api.get_response(uri).body
+    end
+  end
+
+  def status
+    @status ||= begin
+      uri = Git::Semaphore::Api.status_uri(project_hash_id, branch_id, auth_token)
+      Git::Semaphore::Api.get_response(uri).body
+    end
+  end
+
+  def commit_status
+    uri = Git::Semaphore::Api.history_uri(project_hash_id, branch_id, auth_token)
+    j = Git::Semaphore::Api.get_response(uri).body
+    builds = JSON.parse(j)['builds']
+    build = builds.detect { |b| b['commit']['id'] == commit }
+  end
+
+  private
+
+  def project_hash_for project_name
+    JSON::parse(projects).find { |project_hash|
+      project_hash['name'] == project_name
+    }
+  end
+
+  def project_hash_id_for project_name
+    project_hash_for(project_name)['hash_id']
+  end
+
+  def project_hash_id
+    project_hash_id_for(project_name)
+  end
+
+  def branch_hash_for branch_name
+    JSON::parse(branches).find { |branch_hash|
+      branch_hash['name'] == branch_name
+    }
+  end
+
+  def branch_id_for branch_name
+    branch_hash_for(branch_name)['id']
+  end
+
+  def branch_id
+    branch_id_for(branch_name).to_s
+  end
+
+end

data/lib/git-semaphore/banner.rb

@@ -0,0 +1,13 @@
+module Git
+  module Semaphore
+
+    BANNER = <<-"EOS"
+Usage: git-semaphore [options]
+
+v#{Git::Semaphore::VERSION}
+
+Options:
+    EOS
+
+  end
+end

data/lib/git-semaphore/copyright.rb

@@ -0,0 +1,6 @@
+module Git
+  module Semaphore
+    # TODO replace hard-coded details with data retrieved from the gemspec
+    COPYRIGHT = "git-semaphore v#{Git::Semaphore::VERSION} Copyright (c) 2012 Peter Vandenberk"
+  end
+end

data/lib/git-semaphore/version.rb

@@ -0,0 +1,5 @@
+module Git
+  module Semaphore
+    VERSION = "0.0.2"
+  end
+end

data/lib/git-semaphore.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+
+require 'grit'
+require 'trollop'
+
+require 'git-semaphore/version'
+require 'git-semaphore/banner'
+require 'git-semaphore/copyright'
+
+require 'git-semaphore/app'
+require 'git-semaphore/api'
+
+module Git
+  module Semaphore
+    # Your code goes here...
+  end
+end

data/spec_helper.rb

@@ -0,0 +1,6 @@
+$:.unshift File.realpath File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'git-command'
+
+require 'pry'
+require 'awesome_print'