codefumes 0.1.10 → 0.2.0

data/features/support/common.rb

@@ -0,0 +1,29 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + "/../../lib/codefumes"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+require 'spec/stubs/cucumber'
+
+include CodeFumes
+
+gem 'aruba'
+require 'aruba'
+
+Before do
+  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  @bin_path  = File.expand_path(File.dirname(__FILE__) + "/../../bin")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+  ENV['CODEFUMES_CONFIG_FILE'] = File.expand_path(File.join(@tmp_root, "codefumes_config_file"))
+  ENV['FUMES_ENV'] = ENV['FUMES_ENV'] || "test"
+end

data/features/support/matchers.rb

@@ -0,0 +1,11 @@
+module Matchers
+  def contain(expected)
+    simple_matcher("contain #{expected.inspect}") do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to contain #{expected.inspect}"
+      matcher.negative_failure_message = "expected #{given.inspect} not to contain #{expected.inspect}"
+      given.index expected
+    end
+  end
+end
+
+World(Matchers)

data/features/synchronizing_repository_with_project.feature

@@ -0,0 +1,33 @@
+Feature: Synchronizing a repository with CodeFumes
+  Keeping a CodeFumes project synchronized with a project's development
+  is a fundamental feature of the site/service.  Synchronizing this data must
+  be as simple, quick, and reliable as possible in order to provide value to
+  the users of the site.
+
+  Scenario: Unsupported repository type
+    When I run "#{@bin_path}/fumes sync"
+    Then it should fail with:
+      """
+      Unsupported
+      """
+    And the exit status should be 1
+
+  Scenario: Successful synchronization
+    Given I have cloned 1 project
+    When I synchronize the project
+    Then the exit status should be 0
+    And the output should contain "Successfully saved"
+    And the output should contain "Visit http://"
+
+  Scenario: Providing feedback when data is being sent to a non-production server
+    Given I have cloned 1 project
+    When I synchronize the project
+    Then the output should contain "non-production"
+    And the output should contain "test.codefumes.com"
+    And the exit status should be 0
+
+  Scenario: Specifying a custom, but non-existant public/private key combination
+    Given I have cloned 1 project
+    And I cd to "project_1/"
+    When I run "#{@bin_path}/fumes sync -p non-existant-pubkey -a non-existant-privkey"
+    And the exit status should be 2

data/lib/codefumes.rb

@@ -1,14 +1,16 @@
-require 'httparty'
-require 'chronic'
+require 'grit'
 
 require 'codefumes/api'
-require 'codefumes/build'
-require 'codefumes/claim'
-require 'codefumes/commit'
 require 'codefumes/config_file'
-require 'codefumes/payload'
-require 'codefumes/project'
+require 'codefumes/errors'
+require 'codefumes/exit_codes'
+require 'codefumes/harvester.rb'
+require 'codefumes/quick_build.rb'
+require 'codefumes/quick_metric.rb'
+require 'codefumes/source_control.rb'
+
+include CodeFumes::API
 
 module CodeFumes
-  VERSION = '0.1.10' unless defined?(CodeFumes::VERSION)
+  VERSION = '0.2.0' unless defined?(CodeFumes::VERSION)
 end

data/lib/codefumes/api.rb

@@ -1,7 +1,16 @@
+require 'httparty'
+require 'chronic'
+
+require 'codefumes/api/build'
+require 'codefumes/api/claim'
+require 'codefumes/api/commit'
+require 'codefumes/api/payload'
+require 'codefumes/api/project'
+
 module CodeFumes
-  class API
+  module API
     include HTTParty
-
+    base_uri 'http://codefumes.com/api/v1/xml'
     format :xml
 
     BASE_URIS = {
@@ -10,16 +19,16 @@ module CodeFumes
       :local      => 'http://codefumes.com.local/api/v1/xml'
     } #:nodoc:
 
-    # Set the connection base for all server requests. Valid options
-    # are +:production+ and +:test+, which connect to
-    # http://codefumes.com and http://test.codefumes.com (respectively).
-    #
-    # +:local+ is also technically supported, but provided for local
-    # testing and likely only useful for CodeFumes.com developers.
-    def self.mode(mode)
-      base_uri(BASE_URIS[mode]) if BASE_URIS[mode]
+    def self.mode=(mode)
+      return if mode.to_s.empty?
+      base_uri(BASE_URIS[mode.to_sym]) if BASE_URIS[mode.to_sym]
     end
 
-    mode(:production)
+    def self.mode?(mode)
+      return false if mode.nil?
+      base_uri == BASE_URIS[mode.to_sym]
+    end
   end
 end
+
+CodeFumes::API.mode= ENV['FUMES_ENV']

data/lib/codefumes/api/build.rb

@@ -0,0 +1,139 @@
+module CodeFumes
+  module API
+    # Represents a specific instance of tests running on
+    # a continuous integration server.  Builds have a name and are
+    # associated with # a specific Commit of a Project and can track
+    # the current status (running, failed, success) and the
+    # start & end times of the Build process.
+    class Build
+      attr_reader   :created_at, :api_uri, :identifier, :commit, :project
+      attr_accessor :started_at, :ended_at, :state, :name
+
+      # Initializes new instance of a Build.
+      #
+      # * commit - Instance of CodeFumes::Commit to associate the Build with
+      # * name   - A name for the build ('ie7', 'specs', etc.)
+      # * state  - Current state of the build (defaults: 'running')
+      #   * valid values: 'running', 'failed', 'successful'
+      # * options - Hash of additional options. Accepts the following:
+      #   * :started_at - Time the build started
+      #   * :ended_at   - Time the build completed (defaults to nil)
+      def initialize(commit, name, state = 'running', options = {})
+        @commit     = commit
+        @project    = commit.project
+        @name       = name
+        @state      = state.to_s
+        @started_at = options[:started_at] || options['started_at'] || Time.now
+        @ended_at   = options[:ended_at]   || options['ended_at']
+      end
+
+      # Overrides existing attributes with those supplied in +options+. This
+      # simplifies the process of updating an object's state when given a response
+      # from the CodeFumes API.
+      #
+      # Valid options are:
+      # * identifier
+      # * name
+      # * state
+      # * started_at
+      # * ended_at
+      # * api_uri
+      #
+      # Returns +self+
+      def reinitialize_from_hash!(options = {})
+        @identifier          = options[:identifier]        || options['identifier']
+        @name                = options[:name]              || options['name']
+        @state               = options[:state]             || options['state']
+        @api_uri             = options[:api_uri]           || options['api_uri']
+        @started_at          = options[:started_at]        || options['started_at']
+        @ended_at            = options[:ended_at]          || options['ended_at']
+        @created_at          = options[:created_at]        || options['created_at']
+        self
+      end
+
+      # Saves the Build instance to CodeFumes.com
+      #
+      # Returns +true+ if successful
+      #
+      # Returns +false+ if request fails
+      # ---
+      # TODO: Make this consistent w/ other class' create/update handling
+      def save
+        response = exists? ? update : create
+
+        case response.code
+          when 201,200
+            reinitialize_from_hash!(response['build'])
+            true
+          else
+            false
+        end
+      end
+
+      # Searches website for Build with the supplied identifier.
+      #
+      # Returns a Build instance if the Build exists and is available,
+      # to the user making the request.
+      #
+      # Returns +nil+ in all other cases.
+      def self.find(commit, build_name)
+        project = commit.project
+        uri = "/projects/#{project.public_key}/commits/#{commit.identifier}/builds/#{build_name}"
+
+        response = API.get(uri)
+
+        case response.code
+          when 200
+            build_params = response["build"] || {}
+            name = build_params["name"]
+            state = build_params["state"]
+            build = Build.new(commit, name, state)
+            build.reinitialize_from_hash!(build_params)
+          else
+            nil
+        end
+      end
+
+
+      # Returns true if the request was successful
+      #
+      # Returns +false+ in all other cases.
+      def destroy
+        uri = "/projects/#{@project.public_key}/commits/#{@commit.identifier}/builds/#{@name}"
+        auth_args = {:username => @project.public_key, :password => @project.private_key}
+
+        response = API.delete(uri, :basic_auth => auth_args)
+
+        case response.code
+          when 200 : true
+          else false
+        end
+      end
+
+      private
+        # Verifies existence of Build on website.
+        #
+        # Returns +true+ if a build with the specified identifier or name is associated with
+        # the specified project/commit
+        #
+        # Returns +false+ if the public key of the Project is not available.
+        def exists?
+          !self.class.find(commit, name).nil?
+        end
+
+        # Saves a new build (makes POST request)
+        def create
+          API.post("/projects/#{project.public_key}/commits/#{commit.identifier}/builds", :query => {:build => standard_content_hash}, :basic_auth => {:username => project.public_key, :password => project.private_key})
+        end
+
+        # Updates an existing build (makes PUT request)
+        def update
+          API.put("/projects/#{project.public_key}/commits/#{commit.identifier}/builds/#{name}", :query => {:build => standard_content_hash}, :basic_auth => {:username => project.public_key, :password => project.private_key})
+        end
+
+        def standard_content_hash
+          {:name => name,:started_at => started_at, :ended_at => ended_at, :state => state}
+        end
+    end
+  end
+end

data/lib/codefumes/api/claim.rb

@@ -0,0 +1,74 @@
+module CodeFumes
+  module API
+    class Claim
+      attr_accessor :created_at
+      SUPPORTED_VISIBILITIES = [:public, :private]
+
+      # Attempts to claim the specified Project instance using the
+      # supplied API key.
+      #
+      # +visibility+ defaults to +:public+. Valid options are +public+
+      # and +private+.
+      #
+      # Similar to Project#claim, but more explicit.
+      #
+      # Returns +true+ if the request is successful, or if the project
+      # was already owned by the user associated with the privided API
+      # key.
+      #
+      # Returns +false+ in all other cases.
+      def self.create(project, api_key, visibility = :public)
+        validate_api_key(api_key)
+        validate_visibility(visibility)
+
+        auth_args = {:username => project.public_key, :password => project.private_key}
+
+        uri = "/projects/#{project.public_key}/claim"
+        response = API.put(uri, :query => {:api_key => api_key, :visibility => visibility}, :basic_auth => auth_args)
+
+        case response.code
+          when 200 : true
+          else false
+        end
+      end
+
+      # Removes a claim on the specified Project instance using the
+      # supplied API key, releasing ownership.  If the project was a
+      # "private" project, this method will convert it to "public".
+      #
+      # Returns true if the request was successful or there was not
+      # an existing owner (the action is idempotent).
+      #
+      # Returns +false+ in all other cases.
+      def self.destroy(project, api_key)
+        validate_api_key(api_key)
+
+        auth_args = {:username => project.public_key, :password => project.private_key}
+
+        uri = "/projects/#{project.public_key}/claim"
+        response = API.delete(uri, :query => {:api_key => api_key}, :basic_auth => auth_args)
+
+        case response.code
+          when 200 : true
+          else false
+        end
+      end
+
+      private
+        def self.validate_api_key(api_key)
+          if api_key.nil? || api_key.empty?
+            msg = "Invalid user api key provided. (provided: '#{api_key}')"
+            raise(Errors::NoUserApiKeyError, msg)
+          end
+        end
+
+        def self.validate_visibility(visibility)
+          unless SUPPORTED_VISIBILITIES.include?(visibility.to_sym)
+            msg = "Unsupported visibility supplied (#{visibility.to_s}). "
+            msg << "Valid options are: #{SUPPORTED_VISIBILITIES.join(', ')}"
+            raise ArgumentError, msg
+          end
+        end
+    end
+  end
+end

data/lib/codefumes/api/commit.rb

@@ -0,0 +1,150 @@
+module CodeFumes
+  module API
+    # Similar to a revision control system, a Commit encompasses a set of
+    # changes to a codebase, who made them, when said changes were applied
+    # to the previous revision of codebase, et cetera.
+    #
+    # A Commit has a concept of 'standard attributes' which will always be
+    # present in a response from CodeFumes.com[http://codefumes.com], such
+    # as the +identifier+, +author+, and +commit_message+ (see the list of
+    # attributes for a comprehensive listing).  In addition to this, users
+    # are able to associate 'custom attributes' to a Commit, allowing
+    # users to link any number of attributes with a commit identifier and
+    # easily retrieve them later.
+    #
+    # One thing to note about Commit objects is that they are read-only.
+    # To associate metrics with a Commit object, a Payload object should
+    # be created and saved.  Refer to the Payload documentation for more
+    # information.
+    class Commit
+      attr_reader :identifier, :author_name, :author_email, :committer_name,
+                  :committer_email, :short_message, :message,:committed_at,
+                  :authored_at, :uploaded_at, :api_uri, :parent_identifiers,
+                  :line_additions, :line_deletions, :line_total,
+                  :affected_file_count, :custom_attributes, :project
+      alias_method :id, :identifier
+      alias_method :sha, :identifier
+
+      # Instantiates a new Commit object
+      #
+      # * +identifier+ - the revision number of the commit (git commit sha, svn version, etc)
+      #
+      # Accepts a Hash of options, including:
+      # * author_email
+      # * author_name
+      # * committer_email
+      # * committer_name
+      # * short_message
+      # * message
+      # * committed_at
+      # * authored_at
+      # * uploaded_at
+      # * api_uri
+      # * parent_identifiers
+      # * line_additions
+      # * line_deletions
+      # * line_total
+      # * affected_file_count
+      # * custom_attributes
+      #
+      # +custom_attributes+ should be a Hash of attribute_name/value
+      # pairs associated with the commit.  All other attributes are
+      # expected to be String values, other than +committed_at+ and
+      # +authored_at+, which are expected to be DateTime objects.
+      # Technically speaking, you could pass anything you wanted into
+      # the fields, but when using with the CodeFumes API, the attribute
+      # values will be of the type String, DateTime, or Hash.
+      def initialize(project, identifier, options = {})
+        @project             = project
+        @identifier          = identifier
+        @author_email        = options[:author_email]        || options["author_email"]
+        @author_name         = options[:author_name]         || options["author_name"]
+        @committer_email     = options[:committer_email]     || options["committer_email"]
+        @committer_name      = options[:committer_name]      || options["committer_name"]
+        @short_message       = options[:short_message]       || options["short_message"]
+        @message             = options[:message]             || options["message"]
+        @committed_at        = options[:committed_at]        || options["committed_at"]
+        @authored_at         = options[:authored_at]         || options["authored_at"]
+        @uploaded_at         = options[:uploaded_at]         || options["uploaded_at"]
+        @api_uri             = options[:api_uri]             || options["api_uri"]
+        @parent_identifiers  = options[:parent_identifiers]  || options["parent_identifiers"]
+        @line_additions      = options[:line_additions]      || options["line_additions"]
+        @line_deletions      = options[:line_deletions]      || options["line_deletions"]
+        @line_total          = options[:line_total]          || options["line_total"]
+        @affected_file_count = options[:affected_file_count] || options["affected_file_count"]
+        @custom_attributes   = options[:custom_attributes]   || options["custom_attributes"] || {}
+        convert_custom_attributes_keys_to_symbols
+      end
+
+      # Returns the name of the author and the email associated
+      # with the commit in a string formatted as:
+      #   "Name [email_address]"
+      #   (ie: "John Doe [jdoe@example.com]")
+      def author
+        "#{author_name} [#{author_email}]"
+      end
+
+      # Returns the name of the committer and the email associated
+      # with the commit in a string formatted as:
+      #   "Name [email_address]"
+      #   (ie: "John Doe [jdoe@example.com]")
+      def committer
+        "#{committer_name} [#{committer_email}]"
+      end
+
+      # Returns the Commit object associated with the supplied identifier.
+      # Returns nil if the identifier is not found.
+      def self.find(project, identifier)
+        response = API.get("/projects/#{project.public_key}/commits/#{identifier}")
+        case response.code
+          when 200
+            return nil if response["commit"].empty?
+            new(project, response["commit"].delete("identifier"), response["commit"])
+          else
+            nil
+        end
+      end
+
+      # Returns a collection of commits associated with the specified
+      # Project public key.
+      def self.all(project)
+        response = API.get("/projects/#{project.public_key}/commits")
+        case response.code
+          when 200
+            return [] if response["commits"].empty? || response["commits"]["commit"].nil?
+            response["commits"]["commit"].map do |commit_data|
+              new(commit_data.delete("identifier"), commit_data)
+            end
+          else
+            nil
+        end
+      end
+
+      # Returns the most recent commit associated with the specified
+      # Project public key.
+      def self.latest(project)
+        response = API.get("/projects/#{project.public_key}/commits/latest")
+        case response.code
+          when 200
+            new(project, response["commit"].delete("identifier"), response["commit"])
+          else
+            nil
+        end
+      end
+
+      # Returns the commit identifier of the most recent commit of with
+      # the specified Project public key.
+      def self.latest_identifier(project)
+        latest_commit = latest(project)
+        latest_commit.nil? ? nil : latest_commit.identifier
+      end
+
+      private
+        def convert_custom_attributes_keys_to_symbols
+          @custom_attributes = @custom_attributes.inject({}) do |results, key_and_value|
+            results.merge! key_and_value.first.to_sym => key_and_value.last
+          end
+        end
+    end
+  end
+end