conduit 0.2.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38426d4ed06704aedc33d972b93160383581e319
+  data.tar.gz: b89d9ef6cc7c13c1ee9fcf492b4c1e2520ddaeab
+SHA512:
+  metadata.gz: 2c8516d726d6e17db237a920e31353e592d6542553d9277eae4f74cf79618dbaac09dd79c98fef70400f924d3b1e51c5ab110f8a23e1441a79a953d30343f4f0
+  data.tar.gz: 5d24fe0a44c971cce8571e5ce217e0f6438c118645a8d7408a4aa43298805703eca0607984531f2fcf6515f9fa4ac090ee7114d9296582687eb9550f26f20fb7

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Foo'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks

data/app/controllers/conduit/responses_controller.rb

@@ -0,0 +1,14 @@
+module Conduit
+  class ResponsesController < ActionController::Base
+
+    # TODO: Determine the actual param the posted content
+    # will be stored in, and modify the code below
+    #
+    def create
+      request = Conduit::Request.find(params[:request_id])
+      request.responses.create(content: params[:content])
+      render nothing: true
+    end
+
+  end
+end

data/app/models/conduit/concerns/storage.rb

@@ -0,0 +1,41 @@
+module Conduit
+  module Concerns
+    module Storage
+      extend ActiveSupport::Concern
+
+      included do
+        attr_writer :content
+
+        after_create  :add_to_storage,      if: :generate_storage_path
+        after_destroy :remove_from_storage, if: :file
+      end
+
+      # Read the content from the storage location
+      #
+      def content
+        @content ||= Conduit::Storage.read(file)
+      end
+
+      private
+
+        # Generate a unique storage key
+        #
+        def generate_storage_path
+          false
+        end
+
+        # Remove the file from remote storage
+        #
+        def remove_from_storage
+          Conduit::Storage.delete(file)
+        end
+
+        # Write the content to the storage location
+        #
+        def add_to_storage
+          Conduit::Storage.write(file, content)
+        end
+
+    end
+  end
+end

data/app/models/conduit/request.rb

@@ -0,0 +1,109 @@
+module Conduit
+  class Request < ActiveRecord::Base
+    include Conduit::Concerns::Storage
+
+    serialize :options, Hash
+
+    # Associations
+
+    has_many :responses,   dependent: :destroy
+    has_many :subscriptions, autosave: true
+
+    # Validations
+
+    validates :driver, presence: true
+    validates :action, presence: true
+
+    # Hooks
+
+    after_initialize  :set_defaults
+    after_update      :notify_subscribers
+
+    # Scopes
+
+    scope :by_action, -> (actions) { where(action: actions) }
+    scope :by_driver, -> (drivers) { where(driver: drivers) }
+    scope :by_status, -> (status)  { where(status: status)  }
+
+    # Methods
+
+    # Overriding this method fixes an issue
+    # where content isn't set until after
+    # the raw action is instantiated
+    #
+    def content
+      raw.view || super
+    end
+
+    # Perform the requested action
+    # for the specified driver
+    #
+    def perform_request
+      if response = raw.perform
+        responses.create(content: response.body)
+      end
+    end
+
+    # Allow creation of subscriptions through the
+    # subscribers virtual attribute.
+    #
+    # NOTE: This is usually possible by default with a
+    #       has_many :through, but with polymorphic
+    #       association it gets more complicated.
+    #
+    def subscribers=(args)
+      args.map do |arg|
+        next unless arg.class < ActiveRecord::Base
+        subscriptions.build(subscriber: arg)
+      end
+    end
+
+    # Fetch a list of subscribers through
+    # the subscriptions association
+    #
+    # NOTE: This is usually possible by default with a
+    #       has_many :through, but with polymorphic
+    #       association it gets more complicated.
+    #
+    def subscribers
+      subscriptions.map(&:subscriber)
+    end
+
+    private
+
+      # Set some default values
+      #
+      def set_defaults
+        self.status ||= "open"
+      end
+
+      # Generate a unique storage key
+      # TODO: Dynamic File Format
+      #
+      def generate_storage_path
+        update_column(:file, File.join("#{id}".reverse!,
+          driver.to_s, action.to_s, "request.xml"))
+      end
+
+      # Notify the requestable that our status
+      # has changed. This is done by calling
+      # a predefined method name on the
+      # requestable instance
+      #
+      def notify_subscribers
+        last_response = responses.last
+        subscribers.each do |subscriber|
+          subscriber.after_conduit_update(action,
+            last_response.parsed_content)
+        end
+      end
+
+      # Raw access to the action instance
+      #
+      def raw
+        @raw ||= Conduit::Util.find_driver(driver,
+          action).new(options.symbolize_keys!)
+      end
+
+  end
+end

data/app/models/conduit/response.rb

@@ -0,0 +1,50 @@
+module Conduit
+  class Response < ActiveRecord::Base
+    include Conduit::Concerns::Storage
+
+    # Associations
+
+    belongs_to :request
+
+    # Validations
+
+    validates :request, presence: true
+
+    # Hooks
+
+    after_create :report_response_status
+
+    # Methods
+
+    delegate :driver, :action, to: :request
+
+    # Raw access to the parser instance
+    #
+    def parsed_content
+      @parsed_content ||= Conduit::Util.find_driver(driver, action, 'parser').new(content)
+    end
+
+    private
+
+      # Generate a storage key based on parent request
+      # TODO: Dynamic File Format
+      #
+      def generate_storage_path
+        update_column(:file, File.join(File.dirname(
+          request.file), "#{id}-response.xml"))
+      end
+
+      # Check for the 'response_status' attribute
+      # from the parsed data, and return that to
+      # the request.
+      #
+      # NOTE: These should be one of the following:
+      #       pending/success/failure
+      #
+      def report_response_status
+        status = parsed_content.response_status
+        request.update_attributes(status: status)
+      end
+
+  end
+end

data/app/models/conduit/subscription.rb

@@ -0,0 +1,6 @@
+module Conduit
+  class Subscription < ActiveRecord::Base
+    belongs_to :subscriber, polymorphic: true
+    belongs_to :request, class_name: 'Conduit::Request'
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Conduit::Engine.routes.draw do
+  resources :responses, only: [:create]
+end

data/db/migrate/20131209223122_create_conduit_requests.rb

@@ -0,0 +1,13 @@
+class CreateConduitRequests < ActiveRecord::Migration
+  def change
+    create_table :conduit_requests do |t|
+      t.string  :driver
+      t.string  :action
+      t.text    :options
+      t.string  :file
+      t.string  :status
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20131209223734_create_conduit_responses.rb

@@ -0,0 +1,10 @@
+class CreateConduitResponses < ActiveRecord::Migration
+  def change
+    create_table :conduit_responses do |t|
+      t.string :file
+      t.references :request, index: true
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20140305202729_create_conduit_subscriptions.rb

@@ -0,0 +1,12 @@
+class CreateConduitSubscriptions < ActiveRecord::Migration
+  def change
+    create_table :conduit_subscriptions do |t|
+      t.references :request, index: true
+      t.integer    :subscriber_id
+      t.string     :subscriber_type
+
+      t.timestamps
+    end
+    add_index :conduit_subscriptions, [:subscriber_type, :subscriber_id]
+  end
+end

data/lib/conduit.rb

@@ -0,0 +1,60 @@
+require 'conduit/engine'
+require 'conduit/acts_as_conduit_subscriber'
+
+module Conduit
+
+  mattr_accessor :app_root
+
+  # Autoload the Conduit base classes
+  # NOTE: Autoloading should be
+  #       concurrency-safe
+  #
+  autoload :Configuration,     'conduit/configuration'
+  autoload :Storage,           'conduit/storage'
+  autoload :Util,              'conduit/util'
+
+  module Core
+
+    # Autoload the Conduit::Core base classes
+    # NOTE: Autoloading should be
+    #       concurrency-safe
+    #
+    autoload :Connection, 'conduit/core/connection'
+    autoload :Render,     'conduit/core/render'
+    autoload :Action,     'conduit/core/action'
+    autoload :Parser,     'conduit/core/parser'
+    autoload :Driver,     'conduit/core/driver'
+
+  end
+
+  module Driver
+
+    class << self
+      # Store a list of available drivers
+      #
+      # e.g.
+      # Conduit::Driver.index
+      # => [:foo, :bar, :baz]
+      #
+      def index
+        @index ||= []
+      end
+
+      # Load the drivers automatically, but only when they're needed
+      #
+      def load_drivers
+        Conduit::Configuration.driver_paths.each do |dir|
+          raise "Directory not found: #{dir}" unless File.exists?(dir)
+          Dir["#{dir}/**/driver.rb"].each do |file|
+            raise "File not found: #{file}" unless File.exists?(file)
+            name = File.dirname(file).split(File::SEPARATOR).last.classify.to_sym
+            index << name.downcase
+            autoload name, file
+          end
+        end
+      end
+
+    end
+  end
+
+end

data/lib/conduit/acts_as_conduit_subscriber.rb

@@ -0,0 +1,41 @@
+module Conduit
+  module ActsAsConduitSubscriber
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Define a method that can be used to inject
+      # methods into an ActiveRecord Model
+      #
+      def acts_as_conduit_subscriber
+        include Conduit::ActsAsConduitSubscriber::LocalInstanceMethods
+
+        has_many :conduit_subscriptions, as: :subscriber, class_name: 'Conduit::Subscription'
+        has_many :conduit_requests, through: :conduit_subscriptions, source: :request
+      end
+
+    end
+
+    # These methods are included when acts_as_conduit_request
+    # is called on an ActiveRecord Model
+    #
+    module LocalInstanceMethods
+
+      # Fire this method after the last conduit
+      # request has been updated
+      #
+      # NOTE: This could probably be better
+      #       handled by observers, or a
+      #       custom callback.
+      #
+      def after_conduit_update(action, parsed_response)
+        # This method should be overriden
+        # on the requestable object
+      end
+
+    end
+
+  end
+end
+
+ActiveRecord::Base.send :include, Conduit::ActsAsConduitSubscriber

data/lib/conduit/configuration.rb

@@ -0,0 +1,43 @@
+#
+# The job of this class is to provide common
+# configuration options to conduit
+#
+
+module Conduit
+  module Configuration
+    class << self
+
+      #
+      # Storage
+      #
+      # Define the storage configuration. This could
+      # include anything from file paths, to
+      # service credentials, and provider
+      #
+      mattr_accessor :storage_config
+      self.storage_config = {
+        provider:   :file,
+        file_path:  Conduit.app_root.join('tmp', 'conduit')
+      }
+
+      #
+      # Drivers
+      #
+      # Define the driver load path
+      # Define an array of drivers to load
+      #
+      mattr_accessor :driver_paths
+      self.driver_paths = ["#{File.dirname(__FILE__)}/drivers"]
+
+      #
+      # Methods
+      #
+      # Read in the configuration
+      #
+      def configure(&block)
+        yield self
+      end
+
+    end
+  end
+end