codefumes 0.1.10 → 0.2.0

data/lib/codefumes/api/payload.rb

@@ -0,0 +1,93 @@
+module CodeFumes
+  module API
+    # Payloads are intended to simplify sending up large amounts of
+    # content at one time.  For example, when sending up the entire
+    # history of a repository, making a POST request for each commit would
+    # require a very large number of requests.  Using a Payload object
+    # allows larger amounts of content to be saved at one time,
+    # significantly reducing the number of requests made.
+    class Payload
+      PAYLOAD_CHARACTER_LIMIT = 4000 #:nodoc:
+
+      attr_reader :project, :created_at
+
+      # +:commit_data+ should be a list of commits and associated data.
+      # An example would be:
+      #
+      #   [{:identifier => "commit_identifer", :files_affected => 3,
+      #     :custom_attributes => {:any_metric_you_want => "value"}}]
+      def initialize(project, commit_data)
+        @project = project
+        @content = {:commits => commit_data}
+      end
+
+      # Saves instance to CodeFumes.com. After a successful save, the
+      # +created_at+ attribute will be populated with the timestamp the
+      # Payload was created.
+      #
+      # Returns +true+ if the Payload does not contain any content to be
+      # saved or the request was successful.
+      #
+      # Returns +false+ if the request failed.
+      def save
+        return true if empty_payload?
+        response = API.post("/projects/#{@project.public_key}/payloads", :query => {:payload => @content}, :basic_auth => {:username => @project.public_key, :password => @project.private_key})
+
+        case response.code
+          when 201
+            @created_at = response['payload']['created_at']
+            true
+          else
+            false
+        end
+      end
+
+      # +save+ requests are made with a standard POST request (not a
+      # multi-part POST), so the request size is limited by the
+      # application server.  The current configuration on CodeFumes.com
+      # limits requests to approximately 8,000 bytes (a little over).  In
+      # order to simplify dealing with these constraints, without
+      # requiring a multi-part POST request, +prepare+ can be used to
+      # "chunk" up the data into Payloads which do not exceed this limit.
+      #
+      # Returns collection of payload objects which fall into the
+      # constraints of a individual payload (ie: length of raw request,
+      # et cetera).
+      #--
+      # TODO: Clean up how the size of the request is constrained, this
+      # is pretty hackish right now (basically guesses how many
+      # characters would be added when HTTParty wraps the content in XML.)
+      def self.prepare(project, commit_data = {})
+        return [] if commit_data.nil? || commit_data.empty?
+        raw_payload = commit_data.dup
+
+        content = raw_payload[:commits]
+        initial_chunks = {:on_deck => [], :prepared => []}
+
+        # TODO: Clean this up
+        chunked = content.inject(initial_chunks) do |chunks, new_commit|
+          if chunks[:on_deck].to_s.length + new_commit.to_s.length >= PAYLOAD_CHARACTER_LIMIT
+            chunks[:prepared] << chunks[:on_deck]
+            chunks[:on_deck] = [new_commit]
+          elsif new_commit == content.last
+            chunks[:on_deck] << new_commit
+            chunks[:prepared] << chunks[:on_deck]
+            chunks[:on_deck] = []
+          else
+            chunks[:on_deck] << new_commit
+          end
+          chunks
+        end
+
+        chunked[:prepared].map do |raw_content|
+          Payload.new(project, raw_content)
+        end
+      end
+
+      private
+        def empty_payload?
+          @content.nil? || @content.empty? || @content[:commits].nil? || @content[:commits].blank?
+        end
+    end
+  end
+end

data/lib/codefumes/api/project.rb

@@ -0,0 +1,158 @@
+module CodeFumes
+  module API
+    # A Project encapsulates the concept of a project on the CodeFumes.com
+    # website.  Each project has a public key, private key, and can have a
+    # name defined.  Projects are also associated with a collection of
+    # commits from a repository.
+    class Project
+      attr_reader :private_key, :short_uri, :community_uri, :api_uri, :build_status
+      attr_accessor :name, :public_key
+
+      def initialize(public_key=nil, private_key = nil, options = {})
+        @public_key    = public_key
+        @private_key   = private_key
+        @name          = options['name']          || options[:name]
+        @short_uri     = options['short_uri']     || options[:short_uri]
+        @community_uri = options['community_uri'] || options[:community_uri]
+        @api_uri       = options['api_uri']       || options[:api_uri]
+        @build_status  = options['build_status']  || options[:build_status]
+      end
+
+      # Creates new project
+      def self.create
+        response = API.post('/projects')
+
+        case response.code
+          when 201
+            new.reinitialize_from_hash!(response['project'])
+          else
+            false
+        end
+      end
+
+      # Deletes project from the website. You must have both the +public_key+
+      # and +private_key+ of a project in order to delete it.
+      #
+      # Returns +true+ if the request succeeded.
+      #
+      # Returns +false+ if the request failed.
+      def delete
+        if public_key.nil? || private_key.nil?
+          msg = "You must have both the private key & public key of a project in order to delete it. (currently: {:private_key => '#{private_key.to_s}', :public_key => '#{public_key.to_s}'}"
+          raise Errors::InsufficientCredentials, msg
+        end
+
+        response = destroy!
+        case response.code
+          when 200
+            return true
+          else
+            return false
+        end
+      end
+
+      # Attempts to save current state of project to CodeFumes.
+      #
+      # Returns +true+ if the request succeeded.
+      #
+      # Returns +false+ if the request failed.
+      def save
+        response = API.put("/projects/#{public_key}", :query => {:project => {:name => name}},
+                                  :basic_auth => {:username => public_key, :password => private_key})
+
+        case response.code
+          when 200
+            reinitialize_from_hash!(response['project'])
+            true
+          else
+            false
+        end
+      end
+
+      # Serializes a Project instance to a format compatible with the
+      # CodeFumes config file.
+      def to_config
+        project_attributes = {:api_uri => api_uri, :short_uri => short_uri}
+        project_attributes[:private_key] = private_key unless private_key.nil?
+        {public_key.to_sym => project_attributes}
+      end
+
+      # Searches website for project with the supplied public key.
+      #
+      # Returns a Project instance if the project exists and is available,
+      # to the user making the request.
+      #
+      # Returns +nil+ in all other cases.
+      def self.find(public_key)
+        return nil if public_key.nil? || public_key.to_s.empty?
+        response = API.get("/projects/#{public_key}")
+        case response.code
+          when 200
+            project = Project.new
+            project.reinitialize_from_hash!(response['project'])
+          else
+            nil
+        end
+      end
+
+      # Attempts to claim "ownership" of the project using the API key
+      # defined in the "credentials" section of your CodeFumes config
+      # file.
+      #
+      # If you need to claim a project for a key that is not defined in
+      # your config file, refer to Claim#create.
+      #
+      # Returns true if the request is successful.
+      #
+      # Returns +false+ in all other cases.
+      def claim
+        Claim.create(self, ConfigFile.api_key)
+      end
+
+      # Attempts to relinquish "ownership" of the project using the API key
+      # defined in the "credentials" section of your CodeFumes config
+      # file.
+      #
+      # If you need to relinquish ownership of a project for a key that is
+      # not defined in your config file, refer to Claim#delete.
+      #
+      # Returns true if the request is successful.
+      #
+      # Returns +false+ in all other cases.
+      def release
+        Claim.destroy(self, ConfigFile.api_key)
+      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:
+      # * name
+      # * public_key
+      # * private_key
+      # * short_uri
+      # * community_uri
+      # * api_uri
+      # * build_status
+      #
+      # Returns +self+
+      def reinitialize_from_hash!(options = {}) #:nodoc:
+        @name          = options['name']          || options[:name]
+        @public_key    = options['public_key']    || options[:public_key]
+        @private_key   = options['private_key']   || options[:private_key]
+        @short_uri     = options['short_uri']     || options[:short_uri]
+        @community_uri = options['community_uri'] || options[:community_uri]
+        @api_uri       = options['api_uri']       || options[:api_uri]
+        @build_status  = options['build_status']  || options[:build_status]
+        self
+      end
+
+
+      private
+        def destroy!
+          API.delete("/projects/#{@public_key}", :basic_auth => {:username => @public_key, :password => @private_key})
+        end
+    end
+  end
+end

data/lib/codefumes/cli_helpers.rb

@@ -0,0 +1,54 @@
+module CodeFumes
+  # Module with convenience methods used in 'fumes' command line executable
+  module CLIHelpers #nodoc
+    def public_keys_specified(options)
+      return ConfigFile.public_keys if options[:all]
+      [options[:public_key] || SourceControl.new('./').public_key]
+    end
+
+    def print_api_mode_notification
+      puts "NOTE: Sending all requests & data to non-production server! (#{API.base_uri})"
+    end
+
+    def issue_project_commands(message, public_keys, &block)
+      public_keys.each do |public_key|
+        print "#{message}...'#{public_key}': "
+        project = Project.find(public_key.to_s)
+        yield(project)
+      end
+
+      puts ""
+      puts "Done!"
+    end
+
+    def wrap_with_standard_feedback(project, &block)
+      if project.nil?
+        puts "Project Not Found."
+      elsif yield != true
+        puts "Denied."
+      else
+        puts "Success!"
+      end
+    end
+
+    def command_doesnt_use_api?(command)
+      [:'api-key'].include?(command.name)
+    end
+
+    # lifted from the Github gem
+    def has_launchy?(&block)
+      begin
+        gem 'launchy'
+        require 'launchy'
+        block.call
+      rescue Gem::LoadError
+        raise Errors::MissingLaunchyGem, "'launchy' gem required, but missing"
+      end
+    end
+
+    # lifted from the Github gem
+    def open_in_browser(url, &block)
+      has_launchy? {Launchy::Browser.new.visit url}
+    end
+  end
+end

data/lib/codefumes/config_file.rb

@@ -67,9 +67,10 @@ module CodeFumes
 
       # Returns a Hash representation of a specific project contained in
       # the CodeFumes config file.
-      def options_for_project(public_key)
+      def options_for_project(project_or_key)
+        public_key = project_or_key.is_a?(Project) ? project_or_key.public_key : project_or_key
         config = serialized
-        public_key && config[:projects] && config[:projects][public_key.to_sym] || {}
+        project_or_key && config[:projects] && config[:projects][public_key.to_sym] || {}
       end
 
       def public_keys

data/lib/codefumes/errors.rb

@@ -0,0 +1,21 @@
+module CodeFumes
+  module Errors #:nodoc:
+    class InsufficientCredentials < StandardError #:nodoc:
+    end
+
+    class UnsupportedScmToolError < StandardError #:nodoc:
+    end
+
+    class UnknownProjectError < StandardError #:nodoc:
+    end
+
+    class NoUserApiKeyError < ArgumentError #:nodoc:
+    end
+
+    class NoApiKeySpecified < ArgumentError #:nodoc:
+    end
+
+    class MissingLaunchyGem < Gem::LoadError #:nodoc:
+    end
+  end
+end

data/lib/codefumes/exit_codes.rb

@@ -0,0 +1,10 @@
+module ExitCodes
+  SUCCESS                    = 0
+  UNSUPPORTED_SCM            = 1
+  PROJECT_NOT_FOUND          = 2
+  NO_USER_CREDENTIALS        = 3
+  INCORRECT_USER_CREDENTIALS = 4
+  NO_API_KEY_SPECIFIED       = 5
+  MISSING_DEPENDENCY         = 6
+  UNKNOWN                    = 100
+end

data/lib/codefumes/harvester.rb

@@ -0,0 +1,113 @@
+module CodeFumes
+  # Simple class responsible for creating a project on the CodeFumes
+  # website, storing project information in the CodeFumes config file,
+  # and synchronizing a repository's commit history with CodeFumes.com.
+  #
+  # NOTE: Technically this can be used by anything (obviously), but it
+  # was written with the intention of being used with the
+  # +harvest_repo_metrics+ script, and is essentially geared for that
+  # scenario.
+  class Harvester
+    attr_reader :path
+    DEFAULT_PATH = './' #:nodoc:
+
+    # Accepts the following options:
+    # * +:path+ - the path of the repository to gather information from
+    #   (Defaults to './').
+    # * +:public_key+ - Sets the public key of the project. This
+    #   property will be read from the CodeFumes config file if one
+    #   exists for the repository supplied at +:path+.
+    # * +:private_key+ - Sets the private key of the project. This
+    #   property will be read from the CodeFumes config file if on
+    #   exists for the repository supplied at +:path+.
+    # * +:name+ - Sets the name of the project on the CodeFumes site
+    #
+    # Note:
+    #   Neither the +public_key+ nor +private_key+ is supported
+    #   when creating a new project, but is used when updating an
+    #   existing one. This prevents custom public keys from being
+    #   created, but allows the user to share the public/private
+    #   keys of a project with other users, or use them on other
+    #   machines.
+    def initialize(passed_in_options = {})
+      options = passed_in_options.dup
+      @path       = File.expand_path(options.delete(:path) || DEFAULT_PATH)
+      @repository = SourceControl.new(@path)
+
+      public_key = options[:public_key] || @repository.public_key
+      private_key = options[:private_key] || @repository.private_key
+      @project    = initialize_project(public_key, private_key)
+    end
+
+    # Creates or updates a project information on the CodeFumes site,
+    # synchronizes the repository's commit history, and prints the
+    # results to STDOUT.
+    #
+    # Returns a Hash containing the keys :successful_count and :total_count
+    # if the process succeeded and updates were posted to the server with
+    # their associated values.
+    #
+    # Returns and empty Hash if the local repository is in sync with the
+    # server and no updates were posted.
+    #
+    # Returns +false+ if the process failed.
+    def publish_data!
+      if @project.save
+        store_public_key_in_repository
+        update_codefumes_config_file
+        generate_and_save_payload || {}
+      else
+        false
+      end
+    end
+
+    # Returns the CodeFumes public key of the project that is located
+    # at the supplied path.
+    def public_key
+      @project.public_key
+    end
+
+    # Returns the CodeFumes private key of the project that is located
+    # at the supplied path.
+    def private_key
+      @project.private_key
+    end
+
+    # Returns the CodeFumes 'short uri' of the project that is located
+    # at the supplied path. The 'short uri' is similar to a Tiny URL for
+    # a project.
+    def short_uri
+      @project.short_uri
+    end
+
+    private
+      #TODO: Smarten this up a bit.
+      # - Handle nils more cleanly, etc.
+      # - Don't #create if _something_ was supplied. Verify it was valid or exit.
+      def initialize_project(public_key = nil, private_key = nil)
+        return Project.create if public_key.nil? || public_key.empty?
+
+        msg = "Project public key provided was not found via the API (supplied '#{public_key}')."
+        Project.find(public_key) || raise(Errors::UnknownProjectError, msg)
+      end
+
+      def store_public_key_in_repository
+        @repository.store_public_key(@project.public_key)
+      end
+
+      def update_codefumes_config_file
+        ConfigFile.save_project(@project)
+      end
+
+      def generate_and_save_payload
+        payload = @repository.payload(Commit.latest_identifier(@project), "HEAD")
+        if payload.empty?
+          nil
+        else
+          payloads = Payload.prepare(@project, payload)
+          successful_requests = payloads.select {|payload| payload.save == true}
+          {:successful_count => successful_requests.size, :total_count => payloads.size}
+        end
+      end
+  end
+end