I worked on a project which allowed users to authenticate using oauth with several well known social media platforms. After users had linked all their social media presences; we wanted to import the posts for each user from each platform. This is a (redacted) sample of how I accomplished this:

First, I have a neat little module that allows me to encapsulate a list of handler objects and a notification method that can trigger the correct handler based on how the handler has subscribed itself in the factory. This is a little confusing, but basically, each provider class will initialise itself into the factory object, having subscribed itself to a particularly type of social network which it is able to process (handle). I simply abstracted this code because I thought it might be very handy for other projects which follow a similar pattern to this:

module EventDispatcher
  def setup_listeners
    @event_dispatcher_listeners = {}
  end

  def subscribe(event, &callback)
    (@event_dispatcher_listeners[event] ||= []) << callback
  end

  protected
  def notify(event, *args)
    if @event_dispatcher_listeners[event]
      @event_dispatcher_listeners[event].each do |m|
        m.call(*args) if m.respond_to? :call
      end
    end
    nil
  end
end

Next we need to develop the Factory object to encapsulate our handler objects. It contains all the configuration attributes of our social network platform API keys and secrets, etc. It instantiates with a hash which has a static method #load to read a specified file (or by default a file in /config/social_network_configuration.json) which returns an instance of itself with the contents of the configuration file passed into the constructor:

require File.expand_path('../../event_dispatcher', __FILE__)

module SocialNetworking
  class SocialNetworkFactory
    include EventDispatcher
    attr_reader :configs

    def initialize(data)
      setup_listeners
      @configs = {}
      data.each {|n, o| @configs.store n.downcase.to_param.to_sym, o}
    end

    def process(network, user)
      notify(network, user)
    end

    ##
    # Reads client configuration from a file and returns an instance of the factory
    #
    # @param [String] filename
    #   Path to file to load
    #
    # @return [SocialNetworking::SocialNetworkFactory]
    #   Social network factory with API configuration
    def self.load(filename = nil)
      if filename && File.directory?(filename)
        search_path = File.expand_path(filename)
        filename = nil
      end
      while filename == nil
        search_path ||= File.expand_path("#{Rails.root}/config")
        if File.exist?(File.join(search_path, 'social_network_configuration.json'))
          filename = File.join(search_path, 'social_network_configuration.json')
        elsif search_path == '/' || search_path =~ /[a-zA-Z]:[\/\\]/
          raise ArgumentError,
                'No ../config/social_network_configuration.json filename supplied ' +
                  'and/or could not be found in search path.'
        else
          search_path = File.expand_path(File.join(search_path, '..'))
        end
      end
      data = File.open(filename, 'r') {|file| MultiJson.load(file.read)}
      return self.new(data)
    end
  end
end

The configuration file (/config/social_network_configuration.json) looks something like:

{
    "Facebook": {
        "oauth_access_token": "...",
        "expires": ""
    },
    "SoundCloud": {
        "client_id": "..."
    },
    "Twitter": {
        "access_token": "...",
        "access_token_secret": "...",
        "consumer_key": "...",
        "consumer_secret": "..."
    },
    "YouKu": {
        "client_id": "..."
    },
    "YouTube": {
        "dev_key": "..."
    },
    "Weibo": {
        "app_id": "..."
    }
}

The last part is to create a different handler object for each social network (as each social network has its own specific API for interfacing with the platform. Its pretty basic:

module SocialNetworking
  module Providers
    class NetworkNameProvider

      def initialize(factory)
        # you can access the configurations through the factory
        @app_id = factory.configs[:network_name]['app_id']

        # instruct the factory that this provider handles the
        # 'network_name' social network oauth. The factory will
        # publish the users authorization object to this handler.
        factory.subscribe(:network_name) do |auth|

          # Do stuff ...
          
        end
      end

    end
  end
end

So an example of a Weibo Provider class might look something like this:

require File.expand_path('../../../../lib/net_utilities', __FILE__)
require 'base62'
require 'httpi'

module SocialNetworking
  module Providers
    class WeiboProvider
      include NetUtilities

      def initialize(factory)
        @token = get_token
        @app_id = factory.configs[:weibo]['app_id']

        factory.subscribe(:weibo) do |auth|
          Rails.logger.info "  Checking Weibo user '#{auth.api_id}'"

          begin
            @token = auth.token unless auth.token.nil? # || auth.token_expires < DateTime.now
            request = HTTPI::Request.new 'https://api.weibo.com/2/statuses/user_timeline.json'
            request.query = {source: @app_id, access_token: @token, screen_name: auth.api_id}
            response = HTTPI.get request
            if response.code == 200
              result = MultiJson.load(response.body)
              weibos = result['statuses']

              weibos.each {|post|

                ... do something with the post 
                
              }
            end
            auth.checked_at = DateTime.now
            auth.save!
          rescue Exception => e
            Rails.logger.warn "    Exception caught: #{e.message}"
            @token = get_token
          end
        end
      end


      private

      def get_token
        auth = Authorization.where(provider: 'weibo').where('token_expires < ?', DateTime.now).shuffle.first
        auth = Authorization.where(provider: 'weibo').order(:token_expires).reverse_order.first if auth.nil?
        raise 'Cannot locate viable Weibo authorization token' if auth.nil?
        auth.token
      end

      def uri_hash(id)
        id.to_s[0..-15].to_i.base62_encode.swapcase + id.to_s[-14..-8].to_i.base62_encode.swapcase + id.to_s[-7..-1].to_i.base62_encode.swapcase
      end

    end
  end
end

Of course there are a lot of opportunities too refactor and make the providers better. For example a serious argument could be made that the API handshake should be abstracted to a seperate class to be consumed by the provider rather than the provider doing all the API lifting itself (violates the single-responsibility principal) – but I include it inline to give better idea on how this factory works without getting too abstracted.

The last piece of this puzzle is putting it all together. There are a lot of different ways you could consume this factory; but in this example I am going to do it as a rake task that can be regularly scheduled via a cron task.

Dir["#{File.dirname(__FILE__)}/../social_networking/**/*.rb"].each {|f| load(f)}

namespace :social_media do
  desc 'Perform a complete import of social media posts of all users'
  task import: :environment do
    factory = SocialNetworking::Atlas::SocialNetworkFactory.load
    # Instantiate each of your providers here with the factory object.
    SocialNetworking::Atlas::Providers::NetworkNameProvider.new factory
    SocialNetworking::Atlas::Providers::WeiboProvider.new factory

    # Execute the Oauth authorizations in a random order.
    Authorization.where(muted: false).shuffle.each do |auth|
      factory.process(auth.provider.to_sym, auth)
    end
  end
end

I wouldn’t do this in production though, as you may encounter problems if the task gets triggered when the previous iteration is still running. Additionally, I would recommend leveraging ActiveJob to run each handler which would give massive benefits to execution concurrency and feedback on job successes/failures.

Also, you could get really clever and loop over each file in the /providers directory and include and instantiate them all at once, but I have chosen to explicitly declare it in this example.

As you can see this is a nice little pattern which uses some pseudo-event subscription and processing to allow you to import from multiple APIs and maintaining separation of responsibilities. As we loop over each authorization record, this pattern will automatically hand the auth record to the correct handler. You can also chop and change which providers are registered; as any authorization record that doesn’t have a registered handler for its type, will simply be ignored. This means that if the Weibo API changes and we need to fix our handler; it is trivial to remove the handler from production by commenting it out, and all our other handlers will continue to function like nothing ever happened.

This code was written many years ago; and should work on Ruby versions even as old as 1.8. There are probably many opportunities too refactor and enhance this code substantially using a more recent Ruby SDK. Examples of possible enhancements would be allowing the providers to subscribe to the factory using a &block instead of a symbol and allowing the factory to pass a block into to #process method to give access for additional processing to be executed in the context of the provider; but abstracted from it.

Nevertheless, I hope that this pattern proves useful to anyone needing a design pattern to have a handler automatically selected to process some work without complicated selection logic.