metaforce 0.5.3 → 1.0.0a

data/lib/metaforce/metadata/client.rb

@@ -1,232 +1,14 @@
-require 'metaforce/manifest'
-require 'savon'
-require 'zip/zip'
-require 'base64'
-require 'tmpdir'
-
 module Metaforce
   module Metadata
-    class Client
-
-      # Performs a login and sets the session_id and metadata_server_url.
-      #
-      # +options+ should be hash containing the +:username+, +:password+ and
-      # +:security_token+ keys.
-      #
-      # == Examples
-      #
-      #   Metaforce::Metadata::Client.new :username => "username",
-      #     :password => "password",
-      #     :security_token => "security token"
-      def initialize(options=nil)
-        @session = Services::Client.new(options).session
-        @client = Savon::Client.new File.expand_path("../../../../wsdl/#{Metaforce.configuration.api_version}/metadata.xml", __FILE__) do |wsdl|
-          wsdl.endpoint = @session[:metadata_server_url]
-        end
-        @client.http.auth.ssl.verify_mode = :none
-        @header = {
-            "ins0:SessionHeader" => {
-              "ins0:sessionId" => @session[:session_id]
-            }
-        }
-      end
-
-      # Specify an array of component types to list.
-      #
-      # == Examples
-      #
-      #   # Get a list of apex classes on the server and output the names of each
-      #   client.list(:type => "ApexClass").collect { |t| t[:full_name] }
-      #   #=> ["al__SObjectPaginatorListenerForTesting", "al__IndexOutOfBoundsException", ... ]
-      #
-      #   # Get a list of apex components and apex classes
-      #   client.list([{ :type => "CustomObject" }, { :type => "ApexComponent" }])
-      #   #=> ["ContractContactRole", "Solution", "Invoice_Statements__c", ... ]
-      def list(queries=[])
-        if queries.is_a?(Symbol)
-          queries = { :type => queries.to_s.camelcase }
-        elsif queries.is_a?(String)
-          queries = { :type => queries }
-        end
-        queries = [ queries ] unless queries.is_a?(Array)
-        response = @client.request(:list_metadata) do |soap|
-          soap.header = @header
-          soap.body = {
-            :queries => queries
-          }
-        end
-        return [] unless response.body[:list_metadata_response]
-        response.body[:list_metadata_response][:result]
-      end
-
-      # Describe the organization's metadata and cache the response
-      #
-      # == Examples
-      #
-      #   # List the names of all metadata types
-      #   client.describe[:metadata_objects].collect { |t| t[:xml_name] }
-      #   #=> ["CustomLabels", "StaticResource", "Scontrol", "ApexComponent", ... ]
-      def describe(version=nil)
-        @describe ||= describe!(version)
-      end
-
-      # See +describe+
-      def describe!(version=nil)
-        response = @client.request(:describe_metadata) do |soap|
-          soap.header = @header
-          soap.body = { :api_version => version } unless version.nil?
-        end
-        @describe = response.body[:describe_metadata_response][:result]
-      end
-
-      # Lists all metadata objects on the org. Same as
-      # +client.describe[:metadata_objects]
-      #
-      # == Examples
-      #
-      #   # List the names of all metadata types
-      #   client.metadata_objects.collect { |t| t[:xml_name] }
-      #   #=> ["CustomLabels", "StaticResource", "Scontrol", "ApexComponent", ... ]
-      def metadata_objects(version=nil)
-        describe(version)[:metadata_objects]
-      end
-
-      # Checks the status of an async result. If type is +:retrieve+ or +:deploy+,
-      # it returns the RetrieveResult or DeployResult, respectively
-      #
-      # == Examples
-      # 
-      #   client.status('04sU0000000Wx6KIAS')
-      #   #=> {:done=>true, :id=>"04sU0000000Wx6KIAS", :state=>"Completed", :state_detail_last_modified_date=>#<DateTime: 2012-02-03T18:30:38+00:00 ((2455961j,66638s,0n),+0s,2299161j)>}
-      def status(ids, type=nil)
-        request = "check_status"
-        request = "check_#{type.to_s}_status" unless type.nil?
-        ids = [ ids ] unless ids.is_a?(Array)
-
-        Metaforce.log("Polling server for status on #{ids.join(', ')}")
-
-        response = @client.request(request.to_sym) do |soap|
-          soap.header = @header
-          soap.body = {
-            :ids => ids
-          }
-        end
-        response.body["#{request}_response".to_sym][:result]
-      end
-
-      # Returns true if the deployment with id id is done, false otherwise
-      #
-      # == Examples
-      #
-      #   client.done?('04sU0000000Wx6KIAS')
-      #   #=> true
-      def done?(id)
-        self.status(id)[:done] || false
-      end
-
-      # Deploys +path+ to the organisation. +path+ can either be a path to
-      # a directory or a path to a zip file.
-      #
-      # +options+ can contain any of the following keys:
-      #
-      # +options+: 
-      # See http://www.salesforce.com/us/developer/docs/api_meta/Content/meta_deploy.htm#deploy_options
-      # for a list of _deploy_options_. Options should be convereted from
-      # camelCase to an :underscored_symbol.
-      #
-      # == Examples
-      # 
-      #   deploy = client.deploy File.expand_path("myeclipseproj")
-      #   #=> #<Metaforce::Transaction:0x1159bd0 @id='04sU0000000Wx6KIAS' @type=:deploy>
-      #
-      #   deploy.done?
-      #   #=> true
-      #
-      #   deploy.status[:state]
-      #   #=> "Completed"
-      def deploy(path, options={})
-        if path.is_a?(String)
-          zip_contents = create_deploy_file(path)
-        elsif path.is_a?(File)
-          zip_contents = Base64.encode64(path.read)
-        end
-
-        Metaforce.log('Executing deploy')
-
-        response = @client.request(:deploy) do |soap|
-          soap.header = @header
-          soap.body = {
-            :zip_file => zip_contents,
-            :deploy_options => options[:options] || {}
-          }
-        end
-        Transaction.deployment self, response[:deploy_response][:result][:id]
-      end
-
-      # Performs a retrieve
-      #
-      # See http://www.salesforce.com/us/developer/docs/api_meta/Content/meta_retrieve_request.htm
-      # for a list of _retrieve_request_ options. Options should be convereted from
-      # camelCase to an :underscored_symbol. _retrieve_request_ options should
-      # be specified under the +:options+ key in options.
-      def retrieve(options={})
-        Metaforce.log('Executing retrieve')
-
-        response = @client.request(:retrieve) do |soap|
-          soap.header = @header
-          soap.body = {
-            :retrieve_request => options[:options] || {}
-          }
-        end
-        Transaction.retrieval(self, response[:retrieve_response][:result][:id])
-      end
-
-      # Retrieves files specified in the manifest file (package.xml). Specificy any extra options in +options[:options]+.
-      #
-      # == Examples
-      #
-      #   retrieve = client.retrieve_unpackaged File.expand_path("spec/fixtures/sample/src/package.xml")
-      #   #=> #<Metaforce::Transaction:0x1159bd0 @id='04sU0000000Wx6KIAS' @type=:retrieve>
-      def retrieve_unpackaged(manifest, options={})
-        if manifest.is_a?(Metaforce::Manifest)
-          package = manifest.to_package
-        elsif manifest.is_a?(String)
-          package = Metaforce::Manifest.new(File.open(manifest).read).to_package
-        end
-        options[:options] = {
-          :api_version => Metaforce.configuration.api_version,
-          :single_package => true,
-          :unpackaged => {
-            :types => package
-          }
-        }.merge(options[:options] || {})
-        retrieve(options)
-      end
-
-    private
-
-      def method_missing(name, *args, &block)
-        if name =~ /^list_(.*)$/ && metadata_objects.any? { |m| m[:xml_name] == $1.camelcase }
-            list("#{$1}".to_sym)
-        else
-          super
-        end
-      end
+    class Client < Metaforce::AbstractClient
+      require 'metaforce/metadata/client/file'
+      require 'metaforce/metadata/client/crud'
 
-      # Creates the deploy file, reads in the contents and returns the base64
-      # encoded data
-      def create_deploy_file(dir)
-        Dir.mktmpdir do |path|
-          path = File.join path, 'deploy.zip'
-          Zip::ZipFile.open(path, Zip::ZipFile::CREATE) do |zip|
-            Dir["#{dir}/**/**"].each do |file|
-              zip.add(file.sub("#{File.dirname(dir)}/", ''), file)
-            end
-          end
-          Base64.encode64(File.open(path, "rb").read)
-        end
-      end
+      include Metaforce::Metadata::Client::File
+      include Metaforce::Metadata::Client::CRUD
 
+      endpoint :metadata_server_url
+      wsdl Metaforce.configuration.metadata_wsdl
     end
   end
 end

data/lib/metaforce/services/client.rb

@@ -1,106 +1,65 @@
-require 'savon'
-
 module Metaforce
   module Services
-    class Client
-      # Contains the session_id and metadata_server_url
-      attr_reader :session
-
-      # Initializes a new instance of Client and logs in. _options_ should be a
-      # hash containing the username, password and security token. If options
-      # is nil, it will get the username, password and security token from the
-      # configuration.
-      def initialize(options=nil)
-        @options = options
-        # Convert string keys to hashes
-        @options.dup.each { |key, value| options[key.to_sym] = value } if options.is_a?(Hash)
+    class Client < Metaforce::AbstractClient
+      endpoint :server_url
+      wsdl Metaforce.configuration.partner_wsdl
 
-        @options = {
-          :username => Metaforce.configuration.username,
-          :password => Metaforce.configuration.password,
-          :security_token => Metaforce.configuration.security_token
-        } if @options.nil?
-        @session = self.login(@options[:username], @options[:password], @options[:security_token])
-
-        @client = Savon::Client.new File.expand_path("../../../../wsdl/#{Metaforce.configuration.api_version}/partner.xml", __FILE__) do |wsdl|
-          wsdl.endpoint = @session[:services_url]
-        end
-        @client.http.auth.ssl.verify_mode = :none
-      end
-
-      # Performs a login and retrurns the session
-      def login(username, password, security_token=nil)
-        password = "#{password}#{security_token}" unless security_token.nil?
-        client = Savon::Client.new File.expand_path("../../../../wsdl/#{Metaforce.configuration.api_version}/partner.xml", __FILE__) do |wsdl|
-          wsdl.endpoint = wsdl.endpoint.to_s.sub(/login/, 'test') if Metaforce.configuration.test
-          Metaforce.log("Logging in via #{wsdl.endpoint.to_s}")
-        end
-        client.http.auth.ssl.verify_mode = :none
-
-        response = client.request(:login) do
+      # Public: Sends an email using Salesforce.
+      #
+      # options - Hash of email options (http://www.salesforce.com/us/developer/docs/api/Content/sforce_api_calls_sendemail.htm)
+      #
+      # Examples
+      #
+      #   client.send_email(
+      #     to_addresses: ['foo@bar.com'],
+      #     subject: 'Hello World',
+      #     plain_text_body: 'Hello World'
+      #   )
+      #
+      # Returns the result.
+      def send_email(options={})
+        request :send_email do |soap|
           soap.body = {
-            :username => username,
-            :password => password
+            :messages => options,
+            :attributes! => { 'ins0:messages' => { 'xsi:type' => 'ins0:SingleEmailMessage' } }
           }
         end
-        { :session_id => response.body[:login_response][:result][:session_id],
-          :metadata_server_url =>  response.body[:login_response][:result][:metadata_server_url],
-          :services_url => response.body[:login_response][:result][:server_url] }
       end
 
-      # Returns the layout metadata for the sobject.
-      # If a +record_type_id+ is passed in, it will only return the layout for
-      # that record type.
+      # Public: Retrieves layout information for the specified sobject.
       #
-      # This method is really useful finding out picklist values that are
-      # available for a certain record type
+      # sobject        - String name of the sobject.
+      # record_type_id - String id of a record type to filter on.
       #
-      # == Examples
+      # Examples
       #
-      #   @picklists_for_record_type = client.describe_layout('Account', '0123000000100Rn')[:record_type_mappings][:picklists_for_record_type]
+      #  client.describe_layout('Account', '012000000000000AAA')
       #
-      #   def picklist_values_for(field)
-      #     picklist_values = @picklists_for_record_type.select { |f| f[:picklist_name] == field }.first[:picklist_values]
-      #     picklist_values.select { |p| p[:active] }.collect { |p| [ p[:label], p[:value] ] }
-      #   end
-      #
-      #   picklist_values_for('some_field__c')
-      #   # => [ ['label1', 'value1'], ['label2', 'value2'] ] 
+      # Returns the layout metadata for the sobject.
       def describe_layout(sobject, record_type_id=nil)
-        body = {
-          'sObjectType' => sobject
-        }
-        body['recordTypeID'] = record_type_id if record_type_id
-        response = request(:describe_layout) do |soap|
-          soap.header = header
-          soap.body = body
+        request :describe_layout do |soap|
+          soap.body = { 'sObjectType' => sobject }
+          soap.body.merge!('recordTypeID' => record_type_id) if record_type_id
         end
-        response.body[:describe_layout_response][:result]
-      end
-
-    private
-
-      def header
-        {
-          "ins0:SessionHeader" => {
-            "ins0:sessionId" => @session[:session_id]
-          }
-        }
       end
 
-      def request(*args, &block)
-        begin
-          @client.request(*args, &block)
-        rescue Savon::SOAP::Fault => e
-          if e.message =~ /INVALID_SESSION_ID/
-            @session = self.login(@options[:username], @options[:password], @options[:security_token])
-            @client.request(*args, &block)
-          else
-            raise e
-          end
-        end
+      # Public: Get active picklists for a record type.
+      #
+      # sobject        - String name of the sobject.
+      # record_type_id - String id of a record type to filter on.
+      # field          - String name of the field to get picklist values for.
+      #
+      # Examples
+      #
+      #   client.picklist_values('Account', '012000000000000AAA', 'Some_Field__c')
+      #   # => [['Label', 'Value']]
+      #
+      # Returns the picklist_values
+      def picklist_values(sobject, record_type_id, field)
+        describe_layout(sobject, record_type_id).record_type_mappings.picklists_for_record_type
+          .select { |p| p.picklist_name == field }.first.picklist_values
+          .select { |p| p.active }.collect { |p| [ p.label, p.value ] }
       end
-
     end
   end
 end

data/lib/metaforce/version.rb

@@ -1,3 +1,3 @@
 module Metaforce
-  VERSION = "0.5.3"
+  VERSION = '1.0.0a'
 end

data/lib/metaforce.rb

@@ -1,9 +1,29 @@
+require 'savon'
+require 'hashie'
+require 'active_support/core_ext'
+
 require 'metaforce/version'
-require 'metaforce/core_extensions'
 require 'metaforce/config'
-require 'metaforce/error'
-require 'metaforce/manifest'
-require 'metaforce/services'
-require 'metaforce/metadata'
-require 'metaforce/custom_actions'
-require 'metaforce/login_details'
+require 'metaforce/job'
+require 'metaforce/abstract_client'
+require 'metaforce/services/client'
+require 'metaforce/metadata/client'
+
+module Metaforce
+  autoload :Manifest, 'metaforce/manifest'
+  autoload :Login,    'metaforce/login'
+  autoload :Client,   'metaforce/client'
+
+  class << self
+    # Public: Initializes instances of the metadata and services api clients
+    # and provides helper methods for deploying and retrieving code.
+    def new(*args)
+      Client.new(*args)
+    end
+
+    # Performs a login and retrurns the session
+    def login(options={})
+      Login.new(options.delete(:username), options.delete(:password), options.delete(:security_token)).login
+    end
+  end
+end

data/metaforce.gemspec

@@ -1,30 +1,33 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "metaforce/version"
+$:.push File.expand_path('../lib', __FILE__)
+require 'metaforce/version'
 
 Gem::Specification.new do |s|
-  s.name        = "metaforce"
+  s.name        = 'metaforce'
   s.version     = Metaforce::VERSION
-  s.authors     = ["Eric J. Holmes", "Kevin J. Poorman"]
-  s.email       = ["eric@ejholmes.net", "Kevinp@madronasg.com"]
-  s.homepage    = "https://github.com/ejholmes/metaforce"
+  s.authors     = ['Eric J. Holmes', 'Kevin J. Poorman']
+  s.email       = ['eric@ejholmes.net', 'Kevinp@madronasg.com']
+  s.homepage    = 'https://github.com/ejholmes/metaforce'
   s.summary     = %q{A Ruby gem for interacting with the Salesforce Metadata API}
   s.description = %q{A Ruby gem for interacting with the Salesforce Metadata API}
+  s.post_install_message = <<-EOL
+Warning! Metaforce 1.0.x is a complete rewrite and is not backwards compatible with 0.5.x
+EOL
 
-  s.rubyforge_project = "metaforce"
+  s.rubyforge_project = 'metaforce'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 
-  s.add_dependency "nokogiri", "~> 1.5.0"
-  s.add_dependency "savon", "~> 0.9.7"
-  s.add_dependency "rubyzip", "~> 0.9.5"
-  s.add_dependency "term-ansicolor"
+  s.add_dependency 'savon', '~> 1.2.0'
+  s.add_dependency 'rubyzip', '~> 0.9.9'
+  s.add_dependency 'activesupport'
+  s.add_dependency 'hashie'
 
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "mocha"
-  s.add_development_dependency "savon_spec", "~> 0.1.6"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'savon_spec', '~> 1.3.0'
 end

data/spec/fixtures/package.xml

@@ -13,5 +13,5 @@
     <members>Assets</members>
     <name>StaticResource</name>
   </types>
-  <version>23.0</version>
+  <version>26.0</version>
 </Package>

data/spec/fixtures/requests/send_email/success.xml

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns="urn:partner.soap.sforce.com"><soapenv:Body><sendEmailResponse><result><success>true</success></result></sendEmailResponse></soapenv:Body></soapenv:Envelope>

data/spec/lib/client_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Metaforce::Client do
+  let(:options) { { session_id: 'foobar' } }
+  let(:client) { described_class.new(options) }
+
+  describe '.metadata' do
+    subject { client.metadata }
+    it { should be_a Metaforce::Metadata::Client }
+  end
+
+  describe '.services' do
+    subject { client.services }
+    it { should be_a Metaforce::Services::Client }
+  end
+
+  describe '.method_missing' do
+    %w[services metadata].each do |type|
+      context "when the #{type} client responds to method" do
+        it 'proxies to the method' do
+          client.send(type.to_sym).should_receive(:respond_to?).with(:foobar, false).and_return(true)
+          client.send(type.to_sym).should_receive(:foobar)
+          client.foobar
+        end
+      end
+    end
+
+    context 'when neither client responds to method' do
+      it 'raises an exception' do
+        expect { client.foobar }.to raise_error NoMethodError
+      end
+    end
+  end
+end

data/spec/lib/config_spec.rb

@@ -1,54 +1,12 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Metaforce do
-  describe ".configuration" do
-
-    it "sets the default api version to 23.0" do
-      Metaforce.configuration.api_version.should eq("23.0")
-    end
-
-    it "allows you to configure the api version" do
-      Metaforce.configuration.api_version = "21.0"
-      Metaforce.configuration.api_version.should eq("21.0")
-    end
-
-  end
-
-  describe ".configure" do
-
-    it "allows you to configure the api version" do
-      Metaforce.configure do |config|
-        config.api_version = "21.0"
-      end
-      Metaforce.configuration.api_version.should eq("21.0")
-    end
-
-    context "credentials" do
-
-      it "allows you to set the credentials via the configure block" do
-        Metaforce.configure do |config|
-          config.api_version = "23.0"
-          config.username = "valid"
-          config.password = "password"
-        end
-        savon.expects(:login).with(:username => 'valid', :password => 'password').returns(:success)
-        session = Metaforce::Services::Client.new.session
-        session.should eq({ :session_id => "00DU0000000Ilbh!AQoAQHVcube9Z6CRlbR9Eg8ZxpJlrJ6X8QDbnokfyVZItFKzJsLHIRGiqhzJkYsNYRkd3UVA9.s82sbjEbZGUqP3mG6TP_P8",
-                            :metadata_server_url => "https://na12-api.salesforce.com/services/Soap/m/23.0/00DU0000000Albh",
-                            :services_url => "https://na12-api.salesforce.com/services/Soap/u/23.0/00DU0000000Ilbh" })
-      end
-
-      it "allows you to set the credentials via the configure block" do
-        Metaforce.configure do |config|
-          config.api_version = "23.0"
-          config.username = "valid"
-          config.password = "password"
-        end
-        savon.expects(:login).with(:username => 'valid', :password => 'password').returns(:success)
-        expect { Metaforce::Metadata::Client.new }.to_not raise_error
-      end
-
-    end
-
+  describe '.configuration' do
+    subject { Metaforce.configuration }
+    it { should set_default(:api_version).to('26.0') }
+    it { should set_default(:host).to('login.salesforce.com') }
+    it { should set_default(:endpoint).to('https://login.salesforce.com/services/Soap/u/26.0') }
+    it { should set_default(:partner_wsdl).to(File.expand_path('../../../wsdl/26.0/partner.xml', __FILE__)) }
+    it { should set_default(:metadata_wsdl).to(File.expand_path('../../../wsdl/26.0/metadata.xml', __FILE__)) }
   end
 end

data/spec/lib/job/deploy_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Metaforce::Job::Deploy do
+  let(:client) { double('metadata client') }
+  let(:path) { File.expand_path('../../../fixtures/payload.zip', __FILE__) }
+  let(:job) { described_class.new client, path }
+
+  describe '.payload' do
+    subject { job.payload }
+
+    context 'when the path is a file' do
+      it { should be_a String }
+    end
+
+    context 'when the path is a directory' do
+      let(:path) { File.expand_path('../../../fixtures', __FILE__) }
+      it { should be_a String }
+    end
+  end
+
+  describe '.perform' do
+    before do
+      client.should_receive(:_deploy).with(job.payload, {}).and_return(Hashie::Mash.new(id: '1234'))
+      client.should_receive(:status).any_number_of_times.and_return(Hashie::Mash.new(done: true, state: 'Completed'))
+    end
+
+    subject { job.perform }
+    it { should eq job }
+    its(:id) { should eq '1234' }
+  end
+
+  describe '.result' do
+    let(:response) { Hashie::Mash.new(success: true) }
+
+    before do
+      client.should_receive(:status).with(job.id, :deploy).and_return(response)
+    end
+
+    subject { job.result }
+    it { should eq response }
+  end
+
+  describe '.success?' do
+    let(:response) { Hashie::Mash.new(success: true) }
+
+    before do
+      client.should_receive(:status).with(job.id, :deploy).and_return(response)
+    end
+
+    subject { job.success? }
+    it { should be_true }
+  end
+end