RubyGems - cobranding - Versions diffs - 1.2.2 - Mend

cobranding 1.2.2

Files changed (12) hide show

data/License.txt +674 -0
data/README.rdoc +69 -0
data/Rakefile +37 -0
data/lib/cobranding.rb +11 -0
data/lib/cobranding/helper.rb +28 -0
data/lib/cobranding/layout.rb +208 -0
data/lib/cobranding/persistent_layout.rb +53 -0
data/spec/helper_spec.rb +98 -0
data/spec/layout_spec.rb +151 -0
data/spec/persistent_layout_spec.rb +111 -0
data/spec/spec_helper.rb +34 -0
metadata +106 -0

data/README.rdoc ADDED

@@ -0,0 +1,69 @@
+= Cobranding
+This gem allows you too pull marked up HTML from a URL and use it as a layout in a Rails view.
+== Fetching the layout
+To fetch the layout from a service, you can cal
+  Cobranding::Layout.get(url, options)
+Where +url+ and +options+ are values passed to +SimpleHttpClient+. Additional options available are
+* base_url: set the base url for expanding any relative URLs in the markup
+* method: set to :post to perform a POST instead of a GET request
+== Caching
+If you specify +:ttl+ in the options, the layout will be cached for that many seconds. The cache algorithm also tries to prevent race conditions when the cache expires. Using it can greatly reduce load on the servers.
+You must use a Rails.cache that supports +:expires_in+ on writes to the cache. In Rails 2 the only out of the box cache that will work properly is MemCacheStore.
+== Markup
+The HTML markup in the layout cannot contain any ERB code (<% %>). If any is found, it will be escaped.
+You can put limited markup into the HTML using {{ }} style tags. These tags must be exactly one word and will trigger calling helper methods like *_for_cobranding.
+=== Example
+  <html>
+    <head>
+      <title>{{ page_title }}</title>
+      {{ stylesheets }}
+    </head>
+    <body>
+      {{ content }}
+    </body>
+  </html>
+The tags in this layout will result in calls to
+* page_title_for_cobranding
+* stylesheets_for_cobranding
+* content_for_cobranding
+If any of these helper methods aren't defined, they will be silently ignored. If you need a different naming convention for you helper methods, you can pass in a :prefix or :suffix option to the +evaluate+ or +cobranding_layout+ helper call.
+== Using in a view
+The gem automatically adds a universal helper method that allows you to call the layout. It should be added to a regular old layout view like this:
+  <%= cobranding_layout(url, options) do %>
+    <html>
+      <head>
+        <title><%= page_title_for_cobranding %></title>
+        <%= stylesheets_for_cobranding %>
+      </head>
+      <body>
+        <div id="warning">Warning the layout was not available!</div>
+        <%= content_for_cobranding %>
+      </body>
+    </html>
+  <% end %>
+If the tag includes a block, it will only be called if there was an error evaluating the template. This way, you can provide a default failsafe layout in case the layout service is unavailable. Providing one will keep your site up in this case and can also serve as documentation for what the layouts are expected to look like and what tags they should use.
+== Persisting
+If you have layouts that don't need to be real time, you can persist them to a data store and update them asynchronously via a background job. You simply need to include Cobranding::PersistentLayout in your model. To render the layout, you can then pass in model.layout to the cobranding_layout helper instead of a URL.

data/Rakefile ADDED

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'rake'
+desc 'Default: run unit tests'
+task :default => :test
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  desc 'Run the unit tests'
+  RSpec::Core::RakeTask.new(:test)
+rescue LoadError
+  task :test do
+    raise "You must have rspec 2.0 installed to run the tests"
+  end
+end
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "cobranding"
+    gem.summary = %Q{Provides Rails view layouts from an HTTP service}
+    gem.description = %Q{Provides Rails view layouts from an HTTP service.}
+    gem.authors = ["Brian Durand"]
+    gem.email = ["mdobrota@tribune.com", "ddpr@tribune.com"]
+    gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile", "License.txt"].to_a
+    gem.has_rdoc = true
+    gem.rdoc_options << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+    gem.extra_rdoc_files = ["README.rdoc"]
+    gem.add_dependency('actionpack', '>=3.0.0')
+    gem.add_dependency('rest-client')
+    gem.add_development_dependency('rspec', '>= 2.0.0')
+    gem.add_development_dependency('webmock')
+  end
+  Jeweler::RubygemsDotOrgTasks.new
+rescue LoadError
+end

data/lib/cobranding.rb ADDED

@@ -0,0 +1,11 @@
+require 'active_support/all' unless defined?(ActiveSupport::HashWithIndifferentAccess)
+require 'action_view'
+require 'rack'
+module Cobranding
+  require File.join(File.expand_path(File.dirname(__FILE__)), 'cobranding', 'layout')
+  require File.join(File.expand_path(File.dirname(__FILE__)), 'cobranding', 'helper')
+  autoload :PersistentLayout, File.join(File.expand_path(File.dirname(__FILE__)), 'cobranding', 'persistent_layout')
+  ActionView::Base.send(:include, Helper)
+end

data/lib/cobranding/helper.rb ADDED

@@ -0,0 +1,28 @@
+module Cobranding
+  # This module gets mixed in to ActionView::Helpers so its methods are available in all Rails views.
+  module Helper
+    # Helper method to render a layout. The +url_or_layout+ can either be a URL to a layout service or a Layout object.
+    # The options parameter will only be used if a URL is passed in.
+    #
+    # This method can take a block which should be a fail safe ERB version of the layout that will only be used if the
+    # layout service is unavailable.
+    #
+    # Note that for Rails 2.x applications you must call the tag with a block as <% cobranding_layout do %> while in Rails 3.0
+    # and later you must call it as <%= cobranding_layout do %>.
+    def cobranding_layout (url_or_layout, options = nil, &block)
+      options = options.dup if options
+      evaluate_options = {:prefix => options.delete(:prefix), :suffix => options.delete(:suffix)} if options
+      layout = url_or_layout.is_a?(Layout) ? url_or_layout : Layout.get(url_or_layout, options)
+      layout.evaluate(self, evaluate_options).html_safe
+    rescue SystemExit, Interrupt, NoMemoryError
+      raise
+    rescue Exception => e
+      if block_given?
+        Rails.logger.warn(e) if Rails.logger
+        capture(&block).html_safe
+      else
+        raise e
+      end
+    end
+  end
+end

data/lib/cobranding/layout.rb ADDED

@@ -0,0 +1,208 @@
+require 'erb'
+require 'digest/md5'
+require 'rest-client'
+module Cobranding
+  # This class is used to get layout HTML markup from a service and compile it into Ruby code that can be used
+  # as the layout in a Rails view.
+  class Layout
+    QUOTED_RELATIVE_URL = /(<\w+\s((src)|(href))=(['"]))\/(.*?)(\5[^>]*?>)/i
+    UNQUOTED_RELATIVE_URL = /(<\w+\s((src)|(href))=)\/(.*?)(>|(\s[^>]*?>))/i
+    class << self
+      # Get the layout HTML from a service. The options can be any of the options accepted by SimpleHttpClient
+      # or +:base_url+. Any relative URLs found in the HTML will be expanded to absolute URLs using either the
+      # +:base_url+ option or the +url+ as the base.
+      #
+      # If +:ttl+ is specified in the options, the layout will be cached for that many seconds.
+      #
+      # By default the request will be a GET request. If you need to do a POST, you can pass :method => :post in the options.
+      #
+      # If a block is passed, it will be called with the layout html before the layout is created. This can be used
+      # to munge the layout HTML code if necessary.
+      def get (url, options = {}, &block)
+        return nil if url.blank?
+        options ||= {}
+        options = options.is_a?(HashWithIndifferentAccess) ? options.dup : options.with_indifferent_access
+        ttl = options.delete(:ttl)
+        race_ttl = options.delete(:race_condition_ttl)
+        if Rails.cache && ttl
+          cache_options = {}
+          cache_options[:expires_in] = ttl if ttl
+          cache_options[:race_condition_ttl] = race_ttl if race_ttl
+          key = cache_key(url, options)
+          Rails.cache.fetch(key, cache_options) do
+            layout = fetch_layout(url, options, &block)
+          end
+        else
+          return fetch_layout(url, options, &block)
+        end
+      end
+      # Generate a unique cache key for the layout request.
+      def cache_key (url, options = {})
+        options = options.is_a?(HashWithIndifferentAccess) ? options.dup : options.with_indifferent_access
+        full_uri = full_uri(url, options)
+        params = options.delete(:params)
+        options.delete(:host)
+        options.delete(:port)
+        options.delete(:scheme)
+        options.delete(:base)
+        options.delete(:ttl)
+        options.delete(:timeout)
+        options.delete(:read_timeout)
+        options.delete(:open_timeout)
+        append_params_to_uri!(full_uri, params) if params
+        options_key, query = full_uri.to_s.split('?', 2)
+        if query
+          options_key << '?'
+          options_key << query.split('&').sort.join('&')
+        end
+        options.keys.sort{|a,b| a.to_s <=> b.to_s}.each do |key|
+          options_key << " #{key}=#{options[key]}"
+        end
+        "#{name}.#{Digest::MD5.hexdigest(options_key)}"
+      end
+      protected
+      # Fetch the layout HTML from the service. The block is optional and will be called with the html code.
+      def fetch_layout (url, options, &block)
+        method = options.delete(:method) || :get
+        full_url = full_uri(url, options).to_s
+        base_uri = options[:base_url] ? URI.parse(options.delete(:base_url)) : full_uri(url, options)
+        base_uri.userinfo = nil
+        base_uri.path = "/"
+        base_uri.query = nil
+        base_uri.fragment = nil
+        response = method.to_sym == :post ? RestClient.post(full_url, options) : RestClient.get(full_url, options)
+        html = expand_base_url(response, base_uri.to_s)
+        html = block.call(html) if block
+        layout = new(html)
+      end
+      # Expand any relative URL's found in HTML tags to be absolute URLs with the specified base.
+      def expand_base_url (html, base_url)
+        return html unless base_url
+        base_url = "#{base_url}/" unless base_url.end_with?("/")
+        html.gsub(QUOTED_RELATIVE_URL){|match| "#{$1}#{base_url}#{$6}#{$7}"}.gsub(UNQUOTED_RELATIVE_URL){|match| "#{$1}#{base_url}#{$5}#{$6}"}
+      end
+      private
+      def full_uri (url, options)
+        return url if url.kind_of?(URI)
+        uri = URI.parse(url)
+        base = URI.parse(options[:base]) if options[:base]
+        if uri.scheme == nil
+          host = options[:host]
+          port = options[:port]
+          scheme = options[:scheme]
+          if base and base.scheme
+            host ||= base.host
+            port ||= base.port
+            scheme ||= base.scheme
+          end
+          if host
+            full_url = "#{scheme ? scheme : 'http'}://#{host}"
+            full_url << ":#{port}" if port
+            if base
+              unless uri.to_s[0,1] == '/'
+                full_url << base.path
+                full_url << '/' unless base.path.last == '/'
+              end
+            end
+            full_url << uri.to_s
+            uri = URI.parse(full_url)
+          end
+        end
+        return uri
+      end
+      def append_params_to_uri! (uri, params)
+        unless params.blank?
+          if uri.query.blank?
+            uri.query = url_encode_parameters(params)
+          else
+            uri.query << "&"
+            uri.query << url_encode_parameters(params)
+          end
+        end
+      end
+      def url_encode_parameters (params)
+        params.collect{|name, value| url_encoded_param(name, value)}.join('&')
+      end
+      def url_encoded_param (name, value)
+        if value.kind_of?(Array)
+          return value.collect{|v| url_encoded_param(name, v)}.join('&')
+        else
+          return "#{Rack::Utils.escape(name.to_s)}=#{Rack::Utils.escape(value.to_s)}"
+        end
+      end
+    end
+    attr_accessor :src
+    # Create the Layout. The src will be defined from the HTML passed in.
+    def initialize (html = nil)
+      self.html = html if html
+    end
+    # Set the src by compiling HTML into RHTML and then into Ruby code.
+    def html= (html)
+      self.src = compile(html)
+    end
+    # Evaluate the RHTML source code in the specified context. Any yields will call a helper method
+    # corresponding to the value yielded if it exists. The options :prefix and :suffix can be set to
+    # determine the full method name to call. The default is to suffix values with +_for_cobranding+
+    # so that <tt>yield title</tt> will call +title_for_cobranding+. Setting a different prefix or
+    # suffix can be useful if you are pulling in templates from different sources which use the same
+    # variable names but need different values.
+    def evaluate (context, options = nil)
+      if src
+        prefix = options[:prefix] if options
+        suffix = options[:suffix] if options
+        suffix = "_for_cobranding" unless prefix or suffix
+        evaluator = Object.new
+        eval <<-EOS
+          def evaluator.evaluate
+            #{src}
+          end
+        EOS
+        evaluator.evaluate do |var|
+          method = "#{prefix}#{var}#{suffix}"
+          context.send(method) if context.respond_to?(method)
+        end
+      end
+    end
+    protected
+    # Turn markup in the html into rhtml yield statments. Markup will be in HTML comments containing
+    # listings:var where var is a variable name set using content_for.
+    def rhtml (html)
+      return nil unless html
+      # Strip blank lines 'cuz theres just so many of them
+      rhtml_code = html.gsub(/^\s+$/, "\n").gsub(/[\n\r]+/, "\n")
+      # Escape things that look like ERB since it could be a mistake or it could be malicious
+      rhtml_code.gsub!("<%", "&lt;%")
+      rhtml_code.gsub!("%>", "%&gt;")
+      # Replace special comments with yield tags.
+      rhtml_code.gsub!(/\{\{\s*(\w+)\s*\}\}/){|match| "<%=yield :#{$1}%>"}
+      return rhtml_code
+    end
+    # Compile RHTML into ruby code.
+    def compile (html)
+      ERB.new(rhtml(html), nil, '-').src.freeze if html
+    end
+  end
+end

data/lib/cobranding/persistent_layout.rb ADDED

@@ -0,0 +1,53 @@
+module Cobranding
+  # This module can be mixed in to persistent objects so that layouts can be persisted to a data store. This is very
+  # useful when there are only a few layouts and they don't need to be updated in real time. In this case, you can run
+  # a background task to call fetch_layout on all your persistent layouts to update them asynchronously.
+  #
+  # By default, it will be assumed that the URL for the layout service will be stored in a field called +url+ and
+  # the compiled Layout ruby code will be stored in +src+. You can override these values with +layout_src_attribute+
+  # and +layout_url_attriubte+. In addition, if the URL takes options, you can specify the field that stores the Hash
+  # with +layout_url_options_attribute+.
+  #
+  # If the layout code needs to be munged, set the +:layout_preprocessor+ class attribute to either a symbol that
+  # matches a method name or to a +Proc+.
+  module PersistentLayout
+    def self.included (base)
+      base.class_attribute :layout_src_attribute, :layout_url_attribute, :layout_url_options_attribute, :layout_preprocessor
+    end
+    # Fetch a loyout from the service and store the ruby src code in the src attribute.
+    def fetch_layout
+      layout_url = send(layout_url_attribute || :url)
+      unless layout_url.blank?
+        options = send(layout_url_options_attribute) unless layout_url_options_attribute.blank?
+        options ||= {}
+        preprocessor = self.class.layout_preprocessor
+        if preprocessor && !preprocessor.is_a?(Proc)
+          preprocessor = method(preprocessor)
+        end
+        @layout = preprocessor ? Layout.get(layout_url, options, &preprocessor) : Layout.get(layout_url, options)
+        send("#{self.class.layout_src_attribute || :src}=", @layout.src)
+      end
+    end
+    # Get the layout defined by the src attribute.
+    def layout
+      unless @layout
+        layout_src = send(layout_src_attribute || :src)
+        unless layout_src.blank?
+          @layout = Layout.new
+          @layout.src = layout_src
+        end
+      end
+      @layout
+    end
+    def layout_html= (html)
+      preprocessor = self.class.layout_preprocessor
+      preprocessor = method(preprocessor) if preprocessor && !preprocessor.is_a?(Proc)
+      html = preprocessor.call(html) if preprocessor
+      @layout = Layout.new(html)
+      send("#{self.class.layout_src_attribute || :src}=", @layout.src)
+    end
+  end
+end

data/spec/helper_spec.rb ADDED

@@ -0,0 +1,98 @@
+require File.expand_path('../spec_helper', __FILE__)
+describe Cobranding::Helper do
+  module Cobranding::Helper::TestMethods
+    def content_for_cobranding
+      "Content!"
+    end
+  end
+  let(:view) do
+    view = ActionView::Base.new
+    view.extend(Cobranding::Helper::TestMethods)
+    view
+  end
+  def template(rhtml)
+    handler = ActionView::Template.handler_class_for_extension("erb")
+    ActionView::Template.new(rhtml, "test template", handler, {})
+  end
+  def test_template(rhtml)
+    handler = Template.handler_for_extension("erb")
+    template = Template.new(rhtml, "test template", handler, {})
+    template.extend(Cobranding::Helper)
+    def template.content_for_cobranding
+      "Content!"
+    end
+  end
+  before :each do
+    cache = ActiveSupport::Cache::MemoryStore.new
+    Rails.stub!(:cache).and_return(cache)
+  end
+  it "should render a layout in a view with a Layout" do
+    rhtml = '<%= cobranding_layout(layout) %>'
+    layout = Cobranding::Layout.new("<html><title>Success</title><body>{{content}}</body></html>")
+    view.stub(:layout => layout)
+    view.render(:inline => rhtml).should == "<html><title>Success</title><body>Content!</body></html>"
+  end
+  it "should render a layout in a view with a Layout using custom prefix and suffix on helper methods" do
+    def view._content!
+      "Content with custom prefix/suffix"
+    end
+    url = "http://test.host/layout"
+    rhtml = "<%= cobranding_layout('#{url}', :params => {:x => 1}, :prefix => '_', :suffix => '!') %>"
+    layout = Cobranding::Layout.new("<html><title>Success</title><body>{{content}}</body></html>")
+    Cobranding::Layout.should_receive(:get).with(url, :params => {:x => 1}).and_return(layout)
+    view.stub(:layout => layout)
+    view.render(:inline => rhtml).should == "<html><title>Success</title><body>Content with custom prefix/suffix</body></html>"
+  end
+  it "should render a layout in a view with a URL" do
+    rhtml = '<%= cobranding_layout("http://localhost/layout", :params => {:v => 1}, :ttl => 300) %>'
+    layout = Cobranding::Layout.new("<html><title>Success</title><body>{{content}}</body></html>")
+    key = Cobranding::Layout.cache_key("http://localhost/layout?v=1")
+    Rails.cache.write(key, layout)
+    view.render(:inline => rhtml).should == "<html><title>Success</title><body>Content!</body></html>"
+  end
+  it "should render a layout in a view with an alternate failsafe layout in the body of the cobranding_layout tag" do
+    rhtml = '<%= cobranding_layout("http://localhost/layout", :params => {:v => 1}, :ttl => 300) do -%><html><title>FAIL</title><body><%= content_for_cobranding %></body></html><% end -%>'
+    layout = Cobranding::Layout.new("<html><title>Success</title><body>{{content}}</body></html>")
+    key = Cobranding::Layout.cache_key("http://localhost/layout?v=1")
+    Rails.cache.write(key, layout)
+    view.render(:inline => rhtml).should == "<html><title>Success</title><body>Content!</body></html>"
+  end
+  it "should render a default layout in the body of the cobranding_layout tag in a view" do
+    rhtml = '<%= cobranding_layout("invalid url", :params => {:v => 1}, :ttl => 300) do -%><html><title>FAIL</title><body><%= content_for_cobranding %></body></html><% end -%>'
+    view.render(:inline => rhtml).should == "<html><title>FAIL</title><body>Content!</body></html>"
+  end
+  it "should raise an error if no failsafe layout is specified" do
+    rhtml = '<%= cobranding_layout("http://localhost/layout", :params => {:v => 1}, :ttl => 300) %>'
+    lambda{view.render(:inline => rhtml)}.should raise_error
+  end
+  context "when rendering a failsafe layout" do
+    let(:action_view) { ActionView::Base.new }
+    def block_helper(block, content)
+      "<%= #{block} do %>#{content}<% end %>"
+    end
+    it "should render the default block only once when an exception is raised" do
+      url = "http://p2p.cobranding.bad"
+      expected_output = "Tribune Tower"
+      Cobranding::Layout.should_receive(:get).with(url, nil).and_raise(Exception)
+      output = action_view.render(:inline => block_helper(%(cobranding_layout("#{url}")), expected_output))
+      output.should == expected_output
+    end
+  end
+end