metaforce-beta 1.2.0

data/lib/metaforce/cli.rb

@@ -0,0 +1,130 @@
+require 'listen'
+require 'thor'
+require 'metaforce/reporters'
+
+Metaforce.configure do |config|
+  config.log = false
+  config.threading = false
+end
+
+module Metaforce
+  class CLI < Thor
+    CONFIG_FILE = '.metaforce.yml'
+
+    include Thor::Actions
+
+    class << self
+      def credential_options
+        method_option :username, :aliases => '-u', :desc => 'Username.'
+        method_option :password, :aliases => '-p', :desc => 'Password.'
+        method_option :security_token, :aliases => '-t', :desc => 'Security Token.'
+        method_option :environment, :aliases => '-e', :default => 'default', :desc => 'Environment to use from config file (if present).'
+        method_option :host, :aliases => '-h', :desc => 'Salesforce host to connect to.'
+      end
+
+      def deploy_options
+        method_option :deploy_options, :aliases => '-o', :type => :hash, :default => { :run_all_tests => true }, :desc => 'Deploy Options'
+      end
+
+      def retrieve_options
+        method_option :retrieve_options, :aliases => '-o', :type => :hash, :default => {}, :desc => 'Retrieve Options'
+      end
+    end
+
+    desc 'deploy <path>', 'Deploy <path> to the target organization.'
+
+    credential_options
+    deploy_options
+
+    def deploy(path)
+      say "Deploying: #{path} ", :cyan
+      say "#{options[:deploy_options].inspect}"
+      client.deploy(path, options[:deploy_options].symbolize_keys!)
+        .on_complete { |job| report job.result, :deploy }
+        .on_error(&error)
+        .on_poll(&polling)
+        .perform
+    end
+
+    desc 'retrieve <manifest> <path>', 'Retrieve the components specified in <manifest> (package.xml) to <path>.'
+
+    credential_options
+    retrieve_options
+
+    def retrieve(manifest, path=nil)
+      unless path
+        path = manifest
+        manifest = File.join(path, 'package.xml')
+      end
+      say "Retrieving: #{manifest} ", :cyan
+      say "#{options[:retrieve_options].inspect}"
+      client.retrieve_unpackaged(manifest, options[:retrieve_options].symbolize_keys!)
+        .extract_to(path)
+        .on_complete { |job| report(job.result, :retrieve) }
+        .on_complete { |job| say "Extracted: #{path}", :green }
+        .on_error(&error)
+        .on_poll(&polling)
+        .perform
+    end
+
+    desc 'watch <path>', 'Deploy <path> to the target organization whenever files are changed.'
+
+    credential_options
+    deploy_options
+
+    def watch(path)
+      say "Watching: #{path}"
+      @watching = true
+      Listen.to(path) { deploy path }
+    end
+
+  private
+
+    def report(results, type)
+      reporter = "Metaforce::Reporters::#{type.to_s.camelize}Reporter".constantize.new(results)
+      reporter.report
+      exit 1 if reporter.issues?
+    end
+
+    def exit(status)
+      super(status) if not watching?
+    end
+
+    def watching?
+      !!@watching
+    end
+
+    def error
+      proc { |job| say "Error: #{job.result.inspect}" }
+    end
+
+    def polling
+      proc { |job| say 'Polling ...', :cyan }
+    end
+
+    def client
+      credentials = Thor::CoreExt::HashWithIndifferentAccess.new(environment_config)
+      credentials.merge!(options.slice(:username, :password, :security_token, :host))
+      credentials.tap do |credentials|
+        credentials[:username] ||= ask('username:')
+        credentials[:password] ||= ask('password:')
+        credentials[:security_token] ||= ask('security token:')
+      end
+      Metaforce.configuration.host = credentials[:host]
+      Metaforce.new credentials
+    end
+
+    def environment_config
+      (config && config[options[:environment]]) ? config[options[:environment]] : {}
+    end
+
+    def config
+      YAML.load(File.open(config_file)) if File.exists?(config_file)
+    end
+
+    def config_file
+      File.expand_path(CONFIG_FILE)
+    end
+
+  end
+end

data/lib/metaforce/client.rb

@@ -0,0 +1,31 @@
+module Metaforce
+  class Client
+    def initialize(options = {})
+      @options = options
+    end
+
+    # Public: Used to interact with the Metadata API.
+    def metadata
+      @metadata ||= Metaforce::Metadata::Client.new(@options)
+    end
+
+    # Public: Used to interact with the Services API.
+    def services
+      @services ||= Metaforce::Services::Client.new(@options)
+    end
+
+    def inspect
+      "#<#{self.class} @options=#{@options.inspect}>"
+    end
+
+    def method_missing(method, *args, &block)
+      if metadata.respond_to? method, false
+        metadata.send(method, *args, &block)
+      elsif services.respond_to? method, false
+        services.send(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/metaforce/config.rb

@@ -0,0 +1,100 @@
+module Metaforce
+  class << self
+    attr_writer :log
+
+    # Returns the current Configuration
+    #
+    #    Metaforce.configuration.username = "username"
+    #    Metaforce.configuration.password = "password"
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Yields the Configuration
+    #
+    #    Metaforce.configure do |config|
+    #      config.username = "username"
+    #      config.password = "password"
+    #    end
+    def configure
+      yield configuration
+    end
+
+    def log?
+      @log ||= false
+    end
+
+    def log(message)
+      return unless Metaforce.log?
+      Metaforce.configuration.logger.send :debug, message
+    end
+  end
+
+  class Configuration
+    # The Salesforce API version to use. Defaults to 23.0
+    attr_accessor :api_version
+    # The username to use during login.
+    attr_accessor :username
+    # The password to use during login.
+    attr_accessor :password
+    # The security token to use during login.
+    attr_accessor :security_token
+    # Set this to true if you're authenticating with a Sandbox instance.
+    # Defaults to false.
+    attr_accessor :host
+    # A block that gets called when the session becomes invalid and the
+    # client needs to reauthenticate. Passes in the client and the client
+    # options. The block should set the options to a hash containing a valid
+    # session_id and service urls.
+    attr_accessor :authentication_handler
+    # Enables or disables threading when polling for job status. If disabled,
+    # calling .perform on a job will block until completion and all callbacks
+    # have run. (default: true).
+    attr_accessor :threading
+
+    def initialize
+      @threading = false
+    end
+
+    def api_version
+      @api_version ||= '26.0'
+    end
+
+    def host
+      @host ||= 'login.salesforce.com'
+    end
+
+    def authentication_handler
+      @authentication_handler ||= lambda { |client, options|
+        Metaforce.login(options)
+      }
+    end
+
+    def log=(log)
+      Savon.configure do |config|
+        config.log = log
+      end
+      HTTPI.log = log
+    end
+
+    def partner_wsdl
+      File.join(wsdl, 'partner.xml')
+    end
+
+    def metadata_wsdl
+      File.join(wsdl, 'metadata.xml')
+    end
+
+    def endpoint
+      "https://#{host}/services/Soap/u/#{api_version}"
+    end
+
+    def wsdl
+      File.expand_path("../../../wsdl/#{api_version}", __FILE__)
+    end
+
+    def logger
+      @logger ||= ::Logger.new STDOUT
+    end
+  end
+end

data/lib/metaforce/job.rb

@@ -0,0 +1,203 @@
+require 'zip'
+require 'base64'
+
+module Metaforce
+  class Job
+    DELAY_START = 1
+    DELAY_MULTIPLIER = 2
+
+    autoload :Deploy,   'metaforce/job/deploy'
+    autoload :Retrieve, 'metaforce/job/retrieve'
+    autoload :CRUD,     'metaforce/job/crud'
+
+    # Public: The id of the AsyncResult returned from Salesforce for
+    # this job.
+    attr_reader :id
+
+    # Public: Instantiate a new job. Doesn't actually do anything until
+    # .perform is called.
+    #
+    # Examples
+    #
+    #   job = Metaforce::Job.new(client)
+    #   # => #<Metaforce::Job @id=nil>
+    #
+    # Returns self.
+    def initialize(client)
+      @_callbacks = Hash.new { |h,k| h[k] = [] }
+      @client = client
+    end
+
+    # Public: Perform the job.
+    #
+    # Examples
+    #
+    #   job = Metaforce::Job.new
+    #   job.perform
+    #   # => #<Metaforce::Job @id=nil>
+    #
+    # Returns self.
+    def perform
+      start_heart_beat
+      self
+    end
+
+    # Public: Utility method to determine if .perform has been called yet.
+    #
+    # Returns true if @id is set, false otherwise.
+    def started?
+      !!@id
+    end
+
+    # Public: Register a block to be called when an event occurs.
+    #
+    # Yields the job.
+    #
+    # &block - Proc or Lambda to be run when the event is triggered.
+    #
+    # Examples
+    #
+    #   job.on_complete do |job|
+    #     puts "Job ##{job.id} completed!"
+    #   end
+    #
+    #   job.on_error do |job|
+    #     puts "Job failed!"
+    #   end
+    #
+    #   job.on_poll do |job|
+    #     puts "Polled status for #{job.id}"
+    #   end
+    #
+    # Returns self.
+    #
+    # Signature
+    #
+    #   on_complete(&block)
+    #   on_error(&block)
+    #   on_poll(&block)
+    %w[complete error poll].each do |type|
+      define_method :"on_#{type}" do |&block|
+        @_callbacks[:"on_#{type}"] << block
+        self
+      end
+    end
+
+    # Public: Queries the job status from the API.
+    #
+    # Examples
+    #
+    #   job.status
+    #   # => { :id => '1234', :done => false, ... }
+    #
+    # Returns the AsyncResult (http://www.salesforce.com/us/developer/docs/api_meta/Content/meta_asyncresult.htm).
+    def status
+      @status ||= client.status(id)
+    end
+
+    # Public: Returns true if the job has completed. 
+    #
+    # Examples
+    #
+    #   job.done
+    #   # => true
+    #
+    # Returns true if the job has completed, false otherwise.
+    def done?
+      status.done
+    end
+
+    # Public: Returns the state if the job has finished processing.
+    #
+    # Examples
+    #
+    #   job.state
+    #   # => 'Completed'
+    #
+    # Returns the state of the job.
+    def state
+      status.state
+    end
+
+    # Public: Check if the job is in a given state.
+    #
+    # Examples
+    #
+    #   job.queued?
+    #   # => false
+    #
+    # Returns true or false.
+    #
+    # Signature
+    #
+    #   queued?
+    #   in_progress?
+    #   completed?
+    #   error?
+    %w[Queued InProgress Completed Error].each do |state|
+      define_method :"#{state.underscore}?" do; self.state == state end
+    end
+
+    def inspect
+      "#<#{self.class} @id=#{@id.inspect}>"
+    end
+
+    def self.disable_threading!
+      ActiveSupport::Deprecation.warn <<-WARNING.strip_heredoc
+        Metaforce::Job.disable_threading! is deprecated. Use Metaforce.configuration.threading = false instead.
+      WARNING
+      Metaforce.configuration.threading = false
+    end
+
+  private
+    attr_reader :client
+
+    # Internal: Starts a heart beat in a thread, which polls the job status
+    # until it has completed or timed out.
+    def start_heart_beat
+      if threading?
+        Thread.abort_on_exception = true
+        @heart_beat ||= Thread.new &run_loop
+      else
+        run_loop.call
+      end
+    end
+
+    # Internal: Starts the run loop, and blocks until the job has completed or
+    # failed.
+    def run_loop
+      proc {
+        delay = DELAY_START
+        loop do
+          @status = nil
+          sleep (delay = delay * DELAY_MULTIPLIER)
+          trigger :on_poll
+          if completed? || error?
+            trigger callback_type
+            Thread.stop if threading?
+            break
+          end
+        end
+      }
+    end
+
+    def trigger(type)
+      @_callbacks[type].each do |block|
+        block.call(self)
+      end
+    end
+
+    def callback_type
+      if completed?
+        :on_complete
+      elsif error?
+        :on_error
+      end
+    end
+
+    def threading?
+      Metaforce.configuration.threading
+    end
+
+  end
+end