pagelet_rails 0.1.0

data/app/assets/javascripts/pagelet_rails.js

@@ -0,0 +1,185 @@
+//= require_tree ./views
+//= require pagelet_rails/jquery.ajaxprogress
+
+(function (w) {
+
+  var root = w['PageletRails'] || {};
+  w['PageletRails'] = root;
+
+  root.addParamsToUrl = function( url, data ) {
+    if ( ! $.isEmptyObject(data) ) {
+      url += ( url.indexOf('?') >= 0 ? '&' : '?' ) + $.param(data);
+    }
+    return url;
+  };
+
+  root.appendScriptTag = function (text) {
+    var script = document.createElement( "script" );
+    script.type = "text/javascript";
+    script.text = text;
+    $("body").append(script);
+  };
+
+  root.loadDirectly = function(data) {
+    $.ajax({
+      url: data.url,
+      dataType: 'script',
+      headers: {
+        'X-Pagelet': 'pagelet'
+      }
+    }).done(function(_) {
+    }).fail(function(){
+      var html = JST['views/pagelet_load_failed']({
+        pagelet_url: data.url,
+        reload_function: "PageletRails.loadPagelets('#" + data.id + "');"
+      });
+      data.elem.html(html)
+    });
+  };
+
+  root.loadThroughBatchProxy = function(urls) {
+    if (urls.length == 0) { return; }
+
+    var prev_index = 0;
+
+    $.ajax({
+      url: '/pagelet_proxy',
+      data: {
+        urls: urls
+      },
+      dataType: 'text',
+      cache: false,
+      headers: {
+        'X-Pagelet': 'pagelet'
+      },
+      progress: function(_, progressEvent) {
+        var text = progressEvent.target.responseText;
+        var end_index = -1;
+
+        do {
+          end_index = text.indexOf("\n\n//\n\n", prev_index);
+
+          if (end_index != -1) {
+            var new_text = text.substring(prev_index, end_index);
+
+            eval(new_text);
+
+            prev_index = end_index + 1;
+            // console.log('found');
+            // console.log(new_text);
+          }
+
+        } while (end_index != -1);
+      }
+    });
+  };
+
+  root.loadPagelets = function(selector) {
+    selector = selector || '[data-widget-url]';
+    var groups = {};
+
+    $(selector).each(function(index, elem) {
+      var $el = $(elem);
+      var path = $el.data('widget-url');
+      var group = $el.data('pagelet-group');
+      var id = $el.attr('id');
+
+      var url = root.addParamsToUrl(path, {
+        target_container: id,
+        original_pagelet_options: $el.data('pagelet-options')
+      });
+
+      groups[group] = groups[group] || [];
+      groups[group].push({
+        id: id,
+        elem: $el,
+        url: url,
+        group: group
+      });
+    });
+
+    for (var group_name in groups) {
+      if (groups.hasOwnProperty(group_name)) {
+        var group = groups[group_name];
+
+        if (group.length == 1) {
+          root.loadDirectly(group[0]);
+        } else {
+          var urls = group.map(function(e) { return e.url; });
+          root.loadThroughBatchProxy(urls);
+        }
+      }
+    }
+  };
+
+  root.pageletArrived = function(id, content) {
+    root.placeToContainer(id, content);
+    root.processDataRemoteTags();
+    $(document).trigger('pagelet-loaded');
+  };
+
+  root.placeToContainer = function(id, content) {
+    $('#' + id).html(content);
+  };
+
+  root.processDataRemoteTags = function() {
+    $('form[data-remote]').each(function(index, elem){
+      var $el = $(elem);
+      var container = $el.closest('[data-pagelet-container]');
+
+      if (!container) {
+        return;
+      }
+
+      var hidden_field = $el.find('input[name=target_container]')[0];
+      if (!hidden_field) {
+        $("<input/>", {
+          name: "target_container",
+          type: "hidden",
+          value: container.attr('id')
+        }).appendTo($el);
+      }
+
+      hidden_field = $el.find('input[name=original_pagelet_options]')[0];
+      if (!hidden_field) {
+        $("<input/>", {
+          name: "original_pagelet_options",
+          type: "hidden",
+          value: container.data('pagelet-options')
+        }).appendTo($el);
+      }
+    });
+
+    var selector = 'a[data-remote]:not([disabled]),button[data-remote]:not([disabled])';
+    $(selector).each(function(index, elem){
+      var $el = $(elem);
+      var container = $el.closest('[data-pagelet-container]');
+
+      if (!container) {
+        return;
+      }
+
+      var params = $el.data('params');
+      if (!params) {
+        var value = $.param({
+          target_container: container.attr('id'),
+          original_pagelet_options: container.data('pagelet-options')
+        });
+        $el.data('params', value);
+      }
+    });
+  };
+
+  function initialise() {
+    document.addEventListener("turbolinks:load", function(){
+      root.loadPagelets();
+      root.processDataRemoteTags();
+    });
+  }
+
+  initialise();
+})(window);
+
+
+
+

data/app/assets/javascripts/views/modal_dialog.jst.ejs

@@ -0,0 +1,13 @@
+<div class="modal-dialog">
+    <div class="modal-content">
+        <div class="modal-body">
+            <% if (state == 'loading') { %>
+                <p>Loading...</p>
+            <% } %>
+
+            <% if (state == 'error') { %>
+                <p>This page could not be loaded. Please try again later.</p>
+            <% } %>
+        </div>
+    </div>
+</div>

data/app/assets/javascripts/views/modal_dialog_iframe.jst.ejs

@@ -0,0 +1,7 @@
+<div class="modal-dialog modal-lg">
+    <div class="modal-content">
+        <div class="modal-body">
+          <iframe src="<%= src %>" style="zoom:0.60" width="99.6%" height="0" frameborder="0"></iframe>
+        </div>
+    </div>
+</div>

data/app/assets/javascripts/views/pagelet_load_failed.jst.ejs

@@ -0,0 +1,7 @@
+Error occurred during loading
+<div class="debug">
+
+   <a href="<%= pagelet_url %>" target="_blank">Open in new tab</a>
+
+  <a href="javascript:<%= reload_function %>"> Reload </a>
+</div>

data/app/assets/javascripts/views/pagelet_loading_overlay.jst.ejs

@@ -0,0 +1,15 @@
+<div class="pagelet-loading-overlay fade">
+  <div style="display: table; overflow: hidden; width: 100%; height:auto;">
+    <div style="display: table-cell; vertical-align: middle;">
+      <div class="pagelet-loading-overlay__content">
+        <span class="spinner spinner-three-bounce">
+          <div class="bounce1"></div>
+          <div class="bounce2"></div>
+          <div class="bounce3"></div>
+        </span>
+        <br>
+        <span>Loading...</span>
+      </div>
+    </div>
+  </div>
+</div>

data/app/controllers/pagelet_controller.rb

@@ -0,0 +1,4 @@
+class PageletController < ::ApplicationController
+  include PageletRails::Concerns::Controller
+
+end

data/app/controllers/pagelet_proxy_controller.rb

@@ -0,0 +1,20 @@
+class PageletProxyController < ::ApplicationController
+  include ActionController::Live
+  include PageletsHelper
+
+  def show
+    @urls = params[:urls]
+
+    response.headers['Content-Type'] = 'text/javascript'
+
+    response.stream.write "\n"
+
+    @urls.each do |url|
+      response.stream.write pagelet(url)
+      response.stream.write "\n\n//\n\n"
+    end
+  ensure
+    response.stream.close
+  end
+
+end

data/app/helpers/pagelets_helper.rb

@@ -0,0 +1,82 @@
+module PageletsHelper
+
+  def pagelet_stream
+    return nil if pagelet_stream_objects.empty?
+    pagelet_stream_objects.each do |key, block|
+      concat content_tag('script', raw("PageletRails.pageletArrived('#{key}', '#{j capture(&block)}');\n"), type: 'text/javascript')
+    end
+    nil
+  end
+
+  def pagelet_default_id
+    "pagelet_#{rand(2**60).to_s(36)}"
+  end
+
+  def add_pagelet_stream key, &block
+    objects = pagelet_stream_objects
+    raise "duplicate key: #{key}" if objects.has_key?(key)
+    objects[key] = block
+    request.instance_variable_set(:@pagelet_stream_objects, objects)
+  end
+
+  def pagelet_stream_objects
+    request.instance_variable_get(:@pagelet_stream_objects) || {}
+  end
+
+  def pagelet path, p_options = {}
+    puts "Rendering pagelet #{path}".blue
+
+    p_params = p_options.delete(:params) { {} }.with_indifferent_access
+
+    if path.is_a? Symbol
+      path = self.send("#{path}_path", p_params)
+    else
+      uri = URI(path)
+      p_params.merge! Rack::Utils.parse_nested_query(uri.query)
+      p_options.merge! remote: false
+    end
+
+    path_opts = Rails.application.routes.recognize_path(path)
+    p_params.reverse_merge!(path_opts)
+
+    controller_class = path_opts[:controller].camelize.concat('Controller').constantize
+    action = path_opts[:action]
+
+
+    if p_options[:remote] == :stream
+      html_id = p_options.dig(:html, :id) || pagelet_default_id
+      p_options.deep_merge! html: { id: html_id }
+
+      add_pagelet_stream html_id, &Proc.new {
+        pagelet path, p_options.merge(remote: false, skip_container: true)
+      }
+    end
+
+    p_options.deep_merge! parent_params: params.to_h
+
+    c = controller_class.new
+    c.pagelet_options p_options
+    c.pagelet_options original_options: p_options
+
+    env = Rack::MockRequest.env_for(path,
+      'REMOTE_ADDR'              => request.env['REMOTE_ADDR'],
+      'HTTP_HOST'                => request.env['HTTP_HOST'],
+      'HTTP_TURBOLINKS_REFERRER' => request.env['HTTP_TURBOLINKS_REFERRER'],
+      'HTTP_USER_AGENT'          => request.env['HTTP_USER_AGENT'],
+      'HTTP_X_CSRF_TOKEN'        => request.env['HTTP_X_CSRF_TOKEN'],
+      'HTTP_X_PAGELET'           => request.env['HTTP_X_PAGELET'],
+      'HTTP_X_REQUESTED_WITH'    => "XMLHttpRequest",
+    )
+
+    p_request = ActionDispatch::Request.new(env)
+    p_request.parameters.clear
+    p_request.parameters.merge! p_params
+
+    p_response = controller_class.make_response! p_request
+    c.dispatch(action, p_request, p_response)
+
+    body = c.response.body
+    body.html_safe
+  end
+
+end

data/app/views/layouts/pagelet_rails/container.html.slim

@@ -0,0 +1,24 @@
+- if pagelet_request? || pagelet_options.skip_container
+  = content_for?(:content) ? yield(:content) : yield
+
+- else
+  ruby:
+    html_opts = pagelet_options.html || {}
+    classes = html_opts.fetch(:class, '').split(' ')
+    classes << "pagelet-#{controller_name}"
+    classes << "pagelet-#{controller_name}-#{action_name}"
+
+    html_opts[:id] ||= pagelet_default_id
+    html_opts[:class] = classes.join(' ')
+
+    html_opts['data-pagelet-container'] = true
+
+    encode_data = pagelet_options.original_options.to_h.except('remote')
+    html_opts['data-pagelet-options'] = PageletRails::Encryptor.encode(encode_data)
+
+    if pagelet_options.ajax_group
+        html_opts['data-pagelet-group'] = pagelet_options.ajax_group
+    end
+
+  div *html_opts
+    = content_for?(:content) ? yield(:content) : yield

data/app/views/layouts/pagelet_rails/inner.slim

@@ -0,0 +1 @@
+= content_for?(:content) ? yield(:content) : yield

data/app/views/layouts/pagelet_rails/loading_placeholder.slim

@@ -0,0 +1,14 @@
+ruby:
+  height = pagelet_options.placeholder.try(:[], :height)
+  text = pagelet_options.placeholder.try(:[], :text) || 'Loading ...'
+  height = height.is_a?(Numeric) ? "#{height}px" : 'auto'
+
+div style="display: table; height: #{height}; overflow: hidden; width: 100%;"
+  div style="display: table-cell; vertical-align: middle;"
+    div.text-center
+      span.spinner.spinner-three-bounce
+        .bounce1
+        .bounce2
+        .bounce3
+      br
+      span = text

data/config/routes.rb

@@ -0,0 +1,7 @@
+Rails.application.routes.draw do
+  
+  PageletRails::Router.load_routes!(self)
+
+  get 'pagelet_proxy' => 'pagelet_proxy#show'
+
+end

data/lib/action_controller/action_caching.rb

@@ -0,0 +1,16 @@
+# Cloned from https://github.com/rails/actionpack-action_caching
+# as it does not support rails 5 yet
+
+require 'action_controller/caching/actions'
+
+module ActionController
+  module Caching
+    eager_autoload do
+      autoload :Actions
+    end
+
+    include Actions
+  end
+end
+
+ActionController::Base.send(:include, ActionController::Caching::Actions)

data/lib/action_controller/caching/actions.rb

@@ -0,0 +1,210 @@
+require 'set'
+
+module ActionController
+  module Caching
+    # Action caching is similar to page caching by the fact that the entire
+    # output of the response is cached, but unlike page caching, every
+    # request still goes through Action Pack. The key benefit of this is
+    # that filters run before the cache is served, which allows for
+    # authentication and other restrictions on whether someone is allowed
+    # to execute such action.
+    #
+    #   class ListsController < ApplicationController
+    #     before_filter :authenticate, except: :public
+    #
+    #     caches_page   :public
+    #     caches_action :index, :show
+    #   end
+    #
+    # In this example, the +public+ action doesn't require authentication
+    # so it's possible to use the faster page caching. On the other hand
+    # +index+ and +show+ require authentication. They can still be cached,
+    # but we need action caching for them.
+    #
+    # Action caching uses fragment caching internally and an around
+    # filter to do the job. The fragment cache is named according to
+    # the host and path of the request. A page that is accessed at
+    # <tt>http://david.example.com/lists/show/1</tt> will result in a fragment named
+    # <tt>david.example.com/lists/show/1</tt>. This allows the cacher to
+    # differentiate between <tt>david.example.com/lists/</tt> and
+    # <tt>jamis.example.com/lists/</tt> -- which is a helpful way of assisting
+    # the subdomain-as-account-key pattern.
+    #
+    # Different representations of the same resource, e.g.
+    # <tt>http://david.example.com/lists</tt> and
+    # <tt>http://david.example.com/lists.xml</tt>
+    # are treated like separate requests and so are cached separately.
+    # Keep in mind when expiring an action cache that
+    # <tt>action: 'lists'</tt> is not the same as
+    # <tt>action: 'lists', format: :xml</tt>.
+    #
+    # You can modify the default action cache path by passing a
+    # <tt>:cache_path</tt> option. This will be passed directly to
+    # <tt>ActionCachePath.new</tt>. This is handy for actions with
+    # multiple possible routes that should be cached differently. If a
+    # block is given, it is called with the current controller instance.
+    # If an object that responds to <tt>call</tt> is given, it'll be called
+    # with the current controller instance.
+    #
+    # And you can also use <tt>:if</tt> (or <tt>:unless</tt>) to pass a
+    # proc that specifies when the action should be cached.
+    #
+    # As of Rails 3.0, you can also pass <tt>:expires_in</tt> with a time
+    # interval (in seconds) to schedule expiration of the cached item.
+    #
+    # The following example depicts some of the points made above:
+    #
+    #   class CachePathCreator
+    #     def initialize(name)
+    #       @name = name
+    #     end
+    #
+    #     def call(controller)
+    #       "cache-path-#{@name}"
+    #     end
+    #   end
+    #
+    #
+    #   class ListsController < ApplicationController
+    #     before_filter :authenticate, except: :public
+    #
+    #     caches_page :public
+    #
+    #     caches_action :index, if: Proc.new do
+    #       !request.format.json?  # cache if is not a JSON request
+    #     end
+    #
+    #     caches_action :show, cache_path: { project: 1 },
+    #       expires_in: 1.hour
+    #
+    #     caches_action :feed, cache_path: Proc.new do
+    #       if params[:user_id]
+    #         user_list_url(params[:user_id, params[:id])
+    #       else
+    #         list_url(params[:id])
+    #       end
+    #     end
+    #
+    #     caches_action :posts, cache_path: CachePathCreator.new('posts')
+    #   end
+    #
+    # If you pass <tt>layout: false</tt>, it will only cache your action
+    # content. That's useful when your layout has dynamic information.
+    #
+    # Warning: If the format of the request is determined by the Accept HTTP
+    # header the Content-Type of the cached response could be wrong because
+    # no information about the MIME type is stored in the cache key. So, if
+    # you first ask for MIME type M in the Accept header, a cache entry is
+    # created, and then perform a second request to the same resource asking
+    # for a different MIME type, you'd get the content cached for M.
+    #
+    # The <tt>:format</tt> parameter is taken into account though. The safest
+    # way to cache by MIME type is to pass the format in the route.
+    module Actions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Declares that +actions+ should be cached.
+        # See ActionController::Caching::Actions for details.
+        def caches_action(*actions)
+          return unless cache_configured?
+          options = actions.extract_options!
+          options[:layout] = true unless options.key?(:layout)
+          filter_options = options.extract!(:if, :unless).merge(only: actions)
+          cache_options  = options.extract!(:layout, :cache_path).merge(store_options: options)
+
+          around_filter ActionCacheFilter.new(cache_options), filter_options
+        end
+      end
+
+      def _save_fragment(name, options)
+        content = ''
+        response_body.each do |parts|
+          content << parts
+        end
+
+        if caching_allowed?
+          write_fragment(name, content, options)
+        else
+          content
+        end
+      end
+
+      def caching_allowed?
+        (request.get? || request.head?) && response.status == 200
+      end
+
+    protected
+      def expire_action(options = {})
+        return unless cache_configured?
+
+        if options.is_a?(Hash) && options[:action].is_a?(Array)
+          options[:action].each { |action| expire_action(options.merge(action: action)) }
+        else
+          expire_fragment(ActionCachePath.new(self, options, false).path)
+        end
+      end
+
+      class ActionCacheFilter # :nodoc:
+        def initialize(options, &block)
+          @cache_path, @store_options, @cache_layout =
+            options.values_at(:cache_path, :store_options, :layout)
+        end
+
+        def around(controller)
+          cache_layout = @cache_layout.respond_to?(:call) ? @cache_layout.call(controller) : @cache_layout
+
+          path_options = if @cache_path.is_a?(Proc)
+            controller.instance_exec(controller, &@cache_path)
+          elsif @cache_path.respond_to?(:call)
+            @cache_path.call(controller)
+          else
+            @cache_path
+          end
+
+          cache_path = ActionCachePath.new(controller, path_options || {})
+
+          body = controller.read_fragment(cache_path.path, @store_options)
+
+          unless body
+            controller.action_has_layout = false unless cache_layout
+            yield
+            controller.action_has_layout = true
+            body = controller._save_fragment(cache_path.path, @store_options)
+          end
+
+          body = controller.render_to_string(body: body, layout: true) unless cache_layout
+
+          controller.response_body = body
+          controller.content_type = Mime[cache_path.extension || :html]
+        end
+      end
+
+      class ActionCachePath
+        attr_reader :path, :extension
+
+        # If +infer_extension+ is +true+, the cache path extension is looked up from the request's
+        # path and format. This is desirable when reading and writing the cache, but not when
+        # expiring the cache - +expire_action+ should expire the same files regardless of the
+        # request format.
+        def initialize(controller, options = {}, infer_extension = true)
+          if infer_extension
+            @extension = controller.params[:format]
+            options.reverse_merge!(format: @extension) if options.is_a?(Hash)
+          end
+
+          path = controller.url_for(options).split('://', 2).last
+          @path = normalize!(path)
+        end
+
+      private
+        def normalize!(path)
+          ext = URI.parser.escape(extension) if extension
+          path << 'index' if path[-1] == ?/
+          path << ".#{ext}" if extension and !path.split('?', 2).first.ends_with?(".#{ext}")
+          URI.parser.unescape(path)
+        end
+      end
+    end
+  end
+end

data/lib/pagelet_rails/concerns/cache.rb

@@ -0,0 +1,65 @@
+module PageletRails::Concerns::Cache
+  extend ActiveSupport::Concern
+
+  included do
+    include ActionController::Caching::Actions
+
+    pagelet_options cache_defaults: {
+      expires_in: 5.seconds,
+      cache_path: {}
+    }
+
+    around_action :pagelet_cache
+  end
+
+  def pagelet_cache &block
+    # puts 'pagelet_cache'.blue
+    cache_enabled = pagelet_options.cache || pagelet_options.cache_path || pagelet_options.expires_in
+
+    if !cache_enabled
+      return yield
+    end
+
+    cache_defaults = (pagelet_options.cache_defaults || {}).to_h.symbolize_keys
+    store_options = cache_defaults.except(:cache_path)
+    store_options[:expires_in] = pagelet_options.expires_in if pagelet_options.expires_in
+
+    cache_path = pagelet_options.cache_path || cache_defaults[:cache_path]
+
+    cache_path = if cache_path.is_a?(Proc)
+      self.instance_exec(self, &cache_path)
+    elsif cache_path.respond_to?(:call)
+      cache_path.call(self)
+    elsif cache_path.is_a?(String)
+      {
+        custom: cache_path
+      }
+    else
+      cache_path
+    end
+    cache_path ||= {}
+    cache_path[:controller] = params[:controller]
+    cache_path[:action] = params[:action]
+
+    path_object = ActionController::Caching::Actions::ActionCachePath.new(self, cache_path)
+    has_cache = fragment_exist?(path_object.path, store_options)
+    pagelet_options has_cache: has_cache
+
+
+    if (pagelet_render_remotely? && has_cache) || !pagelet_render_remotely?
+      cache_options = {
+        layout: false,
+        store_options: store_options,
+        cache_path: cache_path
+      }
+
+      filter = ActionController::Caching::Actions::ActionCacheFilter.new(cache_options)
+
+      filter.around(self, &block)
+
+    else
+      yield
+    end
+  end
+
+end