rails_bridge 0.0.5

data/VERSION

@@ -0,0 +1 @@
+0.0.5

data/app/controllers/rails_bridge/layout_bridge_controller.rb

@@ -0,0 +1,43 @@
+module RailsBridge
+  class LayoutBridgeController < ::ApplicationController
+    def index
+      paths = self.view_paths
+      @layouts = {}
+      paths.each do |path|
+        layouts_path = File.join(path, 'layouts', '*.{erb,haml}')
+        files = Dir.glob( File.join(path, 'layouts', '*.{erb,haml}') )
+        files.each do |file|
+          name = File.basename(file).split('.').first
+          next if name =~ /^_.*/ # ignore partials
+          @layouts[name] ||= file # only the first matching layout in the views path is accessible
+        end
+      end
+      
+    end
+
+    def show
+      @layout_name = params[:id]
+      custom_content_path = File.join( Rails.root, RailsBridge::LAYOUTS_PATH, @layout_name )
+      bridge_views_path = File.join( Rails.root, RailsBridge::VIEWS_PATH )
+      self.prepend_view_path(custom_content_path)
+      self.prepend_view_path(bridge_views_path)
+      string = replace_relative_urls( render_to_string :layout=>@layout_name, :template=>'content' )
+      render :text=>string, :content_type=>'text/plain'
+    end
+    
+    private
+    
+      def replace_relative_urls html
+        substitutions = [
+          [/(<a.*?href\s*=\s*")\//, "$1#{site_url}/"],            # replace anchor URLs
+          [/(<script.*?src\s*?=\s*?")\//, "$1#{site_url}/"],      # replace script URLs
+          [/(<link.*?href\s*=\s*")\//, "$1#{site_url}/"]          # replace stylesheet URLs
+        ]
+        html.mgpsub( substitutions )
+      end
+      
+      def site_url
+        (defined?(RailsBridge::SITE_URL) && RailsBridge::SITE_URL) || "#{request.env['rack.url_scheme']}://#{request.host}:#{request.port}"
+      end
+  end
+end

data/app/views/content.html.erb

@@ -0,0 +1,13 @@
+<!-- 
+
+To put your own templating content into this section, create the following view in your views path:
+
+<default_views_path>/rails_bridge/layout_bridge/layouts/<%= @layou_name %>/content.html.erb
+
+You may also override individual partials to be used for this templatized layout by creating them with the same relative path under
+
+app/rails_bridge/layout_bridge/views
+
+Any partials declared in this directory will have precedence over those in your default views path.
+
+-->

data/app/views/rails_bridge/layout_bridge/index.html.erb

@@ -0,0 +1,6 @@
+<p>Active layouts</p>
+<ul>
+<% @layouts.each do |name, path| %> 
+  <li><%= link_to(name, url_for(:action=>:show, :id=>name)) %> from <%= path %></li> 
+<% end -%>
+</ul>

data/config/routes.rb

@@ -0,0 +1,11 @@
+Rails.application.routes.draw do
+  namespace :rails_bridge do
+    resources :layouts, :controller => "layout_bridge" do
+      member do
+        get :test
+      end
+    end
+    root :to => 'layout_bridge#index'
+  end
+end
+

data/lib/generators/content_bridge/USAGE

@@ -0,0 +1,12 @@
+Description:
+    Creates a RailsBridge::ContentBridge class.
+
+Example:
+    rails generate content_bridge Twitter get_user_status
+
+    This will create:
+        app/rails_bridge/content_bridges
+        app/rails_bridge/content_bridges/twitter_bridge.rb
+    
+    A content_request named 'get_user_status' will be defined in the 
+    generated TwitterContentBridge class.

data/lib/generators/content_bridge/content_bridge_generator.rb

@@ -0,0 +1,9 @@
+  class ContentBridgeGenerator < Rails::Generators::NamedBase
+    argument :requests, :type => :array, :default => [], :banner => "request [request]..."
+    source_root File.expand_path('../templates', __FILE__)
+    
+    def create_class_file
+      template 'content_bridge.rb', File.expand_path(File.join('app/rails_bridge', 'content_bridges', "#{file_name}.rb"))
+    end
+        
+  end

data/lib/generators/content_bridge/templates/content_bridge.rb

@@ -0,0 +1,47 @@
+class <%= class_name %> < RailsBridge::ContentBridge
+  # Uncomment the following options to create defaults to be used by all requests
+  # self.protocol           = 'https'               # defaults to 'http'
+  # self.host               = 'example.com'
+  # self.port               = 8080                  # defaults to 80
+  # self.path               = '/path/to/resource'   # no default
+  # self.params             = {:locale=>'en'}       # no default
+  # self.default_content    = "Content unavailable."
+  # self.on_success {|content| JSON.parse(content)}
+  # self.request_timeout = 1000                  # miliseconds
+  # self.cache_timeout   = 3600                  # seconds
+
+<%- unless requests.any? -%>
+  # # Example request declaration.
+  # # It would be invoked using:
+  # #  <%= class_name %>.get_example
+  # content_request :<%= example %> do |request|
+  #   # Uncomment the following options to override defaults set on the class.
+  #   # request.protocol        = 'https'           
+  #   # request.host            = 'example.com'
+  #   # request.port            = 8080                  
+  #   # request.path            = '/path/to/resource'   
+  #   # request.params          = nil
+  #   # request.default_content = "<%= request.capitalize %> content unavailable."
+  #   # request.on_success nil          
+  #   # request.request_timeout = 500                 # miliseconds
+  #   # request.cache_timeout   = 60                  # seconds
+  # end
+  
+<%- else -%>
+<%- for request in requests -%>
+  content_request :<%= request %> do |request|
+    # Uncomment the following options to override defaults set on the class.
+    # request.protocol        = 'https'           
+    # request.host            = 'example.com'
+    # request.port            = 8080                  
+    # request.path            = '/path/to/resource'   
+    # request.params          = nil
+    # request.default_content = "<%= request.capitalize %> content unavailable."
+    # request.on_success nil          
+    # request.request_timeout = 500                 # miliseconds
+    # request.cache_timeout   = 60                  # seconds
+  end
+
+<%- end -%>
+<%- end -%>
+end

data/lib/rails_bridge.rb

@@ -0,0 +1,16 @@
+module RailsBridge
+end
+
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/hash'
+require 'active_support/cache'
+$libdir = File.join( File.dirname(__FILE__), 'rails_bridge' )
+require File.join( $libdir, 'content_request' )
+require File.join( $libdir, 'content_bridge' )
+
+if defined? Rails
+  require File.join( $libdir, 'engine' )
+else
+  RailsBridge::ContentBridge.cache = ActiveSupport::Cache.lookup_store(:memory_store)
+end
+

data/lib/rails_bridge/content_bridge.rb

@@ -0,0 +1,137 @@
+require 'typhoeus'
+require 'active_support/core_ext/logger'
+
+module RailsBridge
+  # = ContentBridge
+  # 
+  # An abstraction for embedding content from a remote application within a Rails request.
+  class ContentBridge
+    
+    # Class Constants
+    DEFAULT_CONTENT = 'Remote Content Unavailable'
+    DEFAULT_REQUEST_TIMEOUT = 2000 # miliseconds
+    DEFAULT_CACHE_TIMEOUT = 0
+
+    # Class Attributes
+    class_inheritable_accessor :protocol, :host, :port, :path, :params, :request_timeout, :cache_timeout, :default_content
+    class_inheritable_accessor :cache, :logger
+    @@content_requests = {}
+    @@on_success = nil
+        
+    # Initialize Default Class Attribute Values
+    self.request_timeout = DEFAULT_REQUEST_TIMEOUT
+    self.cache_timeout = DEFAULT_CACHE_TIMEOUT
+    self.default_content = DEFAULT_CONTENT    
+    self.cache = nil
+    self.logger = Logger.new(File.open("/dev/null", 'w'))
+    
+    
+    class << self
+      # custom accessor methods
+      def content_requests; @@content_requests; end
+
+      def on_success
+        if block_given?
+          @@on_success = Proc.new
+        else
+          @@on_success
+        end
+      end
+
+      def on_success=(proc)
+        @@on_success = proc
+      end
+
+        
+      def cache_set key, content, expires_in
+        logger.debug "set key: #{key}"
+        self.cache.write( key, content, :expires_in=>expires_in )
+      end
+      
+      def cache_get key
+        logger.debug "get key: #{key}"
+        content = self.cache.fetch(key, :race_condition_ttl=>5.seconds)
+      end
+
+      
+      def get_remote_content( remote, options={} )
+        hydra = Typhoeus::Hydra.hydra # the singleton Hydra
+        hydra.disable_memoization
+        if remote.is_a? Symbol
+          raise "Undefined content_request :#{remote}" unless remote = @@content_requests[remote]
+        end
+        if remote.is_a? Hash
+          remote = RailsBridge::ContentRequest.new remote
+          remote.content_bridge = self
+        end
+        if remote.is_a? RailsBridge::ContentRequest
+          content_request = remote
+          remote_url = content_request.url
+          options[:params] ||= content_request.params
+          options[:request_timeout] ||= content_request.request_timeout
+          options[:cache_timeout] ||= content_request.cache_timeout
+          options[:default_content] ||= content_request.default_content
+          on_success = content_request.on_success
+        else
+          remote_url = remote
+          on_sucess = nil
+        end
+        options[:request_timeout] ||= self.request_timeout
+        options[:cache_timeout] ||= self.cache_timeout
+        options[:timeout] = options.delete(:request_timeout)  # Rename the request timeout param for Typhoeus
+        default_content = options.delete(:default_content) || self.default_content
+        # options[:verbose] = true # for debugging only
+        
+        request = Typhoeus::Request.new(remote_url, options)
+        unless self.cache && request.cache_timeout && request.cache_timeout > 0 && result = cache_get( request.cache_key )
+          result = default_content
+          request.on_complete do |response|
+            case response.code
+            when 200
+              if on_success
+                result = on_success.call(response.body)
+              else
+                result = response.body
+              end
+              cache_set( request.cache_key, result, request.cache_timeout ) if self.cache && request.cache_timeout && request.cache_timeout > 0
+              logger.debug "ContentBridge : Request Succeeded - Content: #{result}"
+            when 0
+              logger.warn "ContentBridge : Request Timeout for #{remote_url}"
+            else
+              logger.warn "ContentBridge : Request for #{remote_url}\mRequest Failed with HTTP result code: #{response.code}\n#{response.body}"
+            end        
+          end
+          hydra.queue request
+          hydra.run # this is a blocking call that returns once all requests are complete
+        end
+        result
+      end
+      
+      def content_request name, options={}
+        raise "name must be a symbol" unless name.is_a? Symbol
+        begin
+          raise "WARNING: Already defined content_request '#{name}'" if @@content_requests.key?( name )
+        rescue
+          logger.warn $!.message
+          logger.warn $!.backtrace * "\n"
+        end
+        new_request = ContentRequest.new options
+        yield new_request if block_given?
+        @@content_requests[name] = new_request
+        new_request.content_bridge = self
+        new_request
+      end
+      
+      def method_missing method, *args
+        if matches = method.to_s.match( /^get_(.*)$/ )
+          request_name = matches[1]
+          self.get_remote_content( request_name.to_sym, *args )
+        else
+          super
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/rails_bridge/content_request.rb

@@ -0,0 +1,100 @@
+require 'uri'
+
+module RailsBridge
+  class ContentRequest
+    attr_accessor :default_content, :request_timeout, :cache_timeout, :protocol, :host, :port, :path, :params, :content_bridge
+    attr_accessor :on_success
+    attr :url
+    
+    # Options:
+    # * :default_content - Content to be returned in test mode or when the remote server is unavailable
+    # * :request_timeout - Maximum time to wait for successful response in ms
+    # * :cache_timeout - TTL expiry for cache in seconds - nil or 0 will prevent caching
+    # * :protocol - Protocol of remote server (http|https).  Default is 'http'
+    # * :host - Host of remote server.  
+    # * :port - Port of remote server.  Default is 80.
+    # * :path - Path for remote request.  Default is '/'
+    # * :params - URL query params for remote request.  
+    # * :fragment - URL part after the '#' for remote request.
+    # * :url - Explicit URL for remote request.
+    #     if the :url option is passed, the :protocol, :host, :port, :path, :params, and :fragment options are ignored
+    def initialize options={}
+      if url = options[:url]
+        self.url = url
+      else
+        self.protocol = options[:protocol]
+        self.host = options[:host]
+        self.port = options[:port]
+        self.path = options[:path]
+        self.params = options[:params]
+      end
+      self.default_content = options[:default_content]
+      self.request_timeout = options[:request_timeout]
+      self.cache_timeout = options[:cache_timeout]
+    end
+    
+    def protocol;   @protocol   || (self.content_bridge && self.content_bridge.protocol) || 'http'; end
+    def host;       @host       || (self.content_bridge && self.content_bridge.host);               end
+    def port;       @port       || (self.content_bridge && self.content_bridge.port)  || 80;        end
+    def path;       @path       || (self.content_bridge && self.content_bridge.path) || '/';        end
+    def params;     @params     || (self.content_bridge && self.content_bridge.params);             end
+    
+    def url= url
+      uri = URI.parse( url )
+      self.protocol = uri.scheme
+      self.host = uri.host
+      self.port = uri.port
+      self.path = uri.path
+      self.params = extract_query_params( uri.query )
+    end
+    
+    # We don't include the params in the URL, because Typhoeus::Request takes them as a separate argument
+    def url
+      URI::Generic.new( self.protocol, nil, self.host, self.port, nil, self.path, nil, nil, nil, true ).to_s
+    end
+    
+    def get_remote_content( options={} )
+      if self.content_bridge
+        self.content_bridge.get_remote_content( self, options )
+      else
+        RailsBridge::ContentBridge.get_remote_content( self, options )
+      end
+    end
+    
+    def on_success
+      if block_given?
+        @on_success = Proc.new
+      else
+        @on_success || (self.content_bridge && self.content_bridge.on_success);
+      end
+    end
+
+    def on_success=(proc)
+      @on_success = proc
+    end
+    
+    private 
+     def extract_query_params query
+       return nil if query.nil?
+       query = CGI::unescape( query )
+       pairs = query.split("&")
+       params = pairs.inject({}){|hash, pair| k,v=pair.split('='); v.nil? ? hash : (hash[k.to_sym]=v;hash)}
+       params.keys.empty? ? nil : params
+     end
+     
+     def encode_query_params params
+       params = escape_query_params( params )
+       params.keys.map{|k| "#{k}=#{params[k]}"}.join('&')
+     end
+     
+     def escape_query_params params
+       return unless params
+       new_params = {}
+       params.each do |k,v|
+         new_params[k] = CGI::escape( v.to_s )
+       end
+       new_params
+     end
+              
+  end
+end

data/lib/rails_bridge/engine.rb

@@ -0,0 +1,34 @@
+module RailsBridge
+  ROOT_PATH = 'app/rails_bridge'
+  LAYOUTS_PATH = File.join(ROOT_PATH, 'layout_bridge', 'layouts')
+  VIEWS_PATH = File.join(ROOT_PATH, 'layout_bridge', 'views')
+
+  # namespace our plugin and inherit from Rails::Railtie
+  # to get our plugin into the initialization process
+  class Engine < Rails::Engine
+    
+
+    # initialize our plugin on boot. 
+    initializer "rails_bridge.initialize" do |app|
+    end
+    
+    config.after_initialize do
+      RailsBridge::ContentBridge.logger = Rails.logger
+      RailsBridge::ContentBridge.cache = Rails.cache
+      RailsBridge::Engine.create_rails_bridge_home
+    end
+    
+    config.autoload_paths << ROOT_PATH
+    
+    def self.create_rails_bridge_home
+      rails_bridge_home = File.join( Rails.root, RailsBridge::ROOT_PATH )
+      FileUtils.mkdir_p( rails_bridge_home ) unless File.exist?( rails_bridge_home )
+      layout_bridge_views_path = File.join( Rails.root, RailsBridge::VIEWS_PATH )
+      layout_bridge_layouts_path = File.join( Rails.root, RailsBridge::LAYOUTS_PATH )
+      FileUtils.mkdir_p( layout_bridge_views_path ) unless File.exist?( layout_bridge_views_path )
+      FileUtils.mkdir_p( layout_bridge_layouts_path ) unless File.exist?( layout_bridge_layouts_path )
+      rails_bridge_home
+    end
+    
+  end
+end