pagelet_rails 0.1.0

data/lib/pagelet_rails/concerns/controller.rb

@@ -0,0 +1,73 @@
+module PageletRails::Concerns::Controller
+  extend ActiveSupport::Concern
+
+  included do
+    # order is important
+    include PageletRails::Concerns::ResponseWrapper
+    include PageletRails::Concerns::Routes
+    include PageletRails::Concerns::Options
+    include PageletRails::Concerns::Cache
+    include PageletRails::Concerns::Placeholder
+
+    prepend_before_action :merge_original_pagelet_options
+    prepend_before_action :append_pagelet_view_paths
+
+    layout :layout_name
+
+    helper_method :pagelet_request?
+
+    pagelet_options layout: 'panel'
+  end
+
+  def layout_name
+    layout = params[:layout] || pagelet_options.layout
+
+    "pagelets/#{layout}"
+  end
+
+  def pagelet_request?
+    request.headers['X-Pagelet'].present? || params[:target_container]
+  end
+
+  private
+
+  def append_pagelet_view_paths
+    self.view_paths.unshift 'app/pagelets/'
+
+    # lookup_context.prefixes.clear
+    view = "#{controller_name}/views"
+    if lookup_context.prefixes.exclude?(view)
+      lookup_context.prefixes.unshift "#{controller_name}/views"
+    end
+
+    # https://github.com/rails/actionpack-action_caching/issues/32
+    if lookup_context.formats.exclude?(:html)
+      lookup_context.formats.unshift :html
+    end
+  end
+
+  def merge_original_pagelet_options
+    if params[:original_pagelet_options]
+      opts = PageletRails::Encryptor.decode(params[:original_pagelet_options])
+      pagelet_options(opts)
+    end
+  end
+
+  def pagelet_render_remotely?
+    case pagelet_options.remote
+    when :stream
+      render_remotely = true
+    when :turbolinks
+      # render now if request coming from turbolinks
+      is_turbolinks_request = request.headers['Turbolinks-Referrer'].present?
+      render_remotely = !is_turbolinks_request
+    when true, :ajax
+      render_remotely = true
+    else
+      render_remotely = false
+    end
+
+    render_remotely
+  end
+
+end

data/lib/pagelet_rails/concerns/options.rb

@@ -0,0 +1,76 @@
+module PageletRails::Concerns::Options
+  extend ActiveSupport::Concern
+
+  included do
+    include Shared
+
+    helper_method :pagelet_options
+  end
+
+  def pagelet_options *args
+    set_pagelet_options *args
+
+    opts = self.class.pagelet_options
+    class_default_opts = opts.fetch('default', {})
+    class_action_opts = opts.fetch(action_name, {})
+
+    instance_default_opts = @pagelet_options.fetch('default', {})
+    instance_action_opts = @pagelet_options.fetch(action_name, {})
+
+    result = {}.with_indifferent_access
+      .deep_merge!(class_default_opts)
+      .deep_merge!(class_action_opts)
+      .deep_merge!(instance_default_opts)
+      .deep_merge!(instance_action_opts)
+
+    OpenStruct.new result
+  end
+
+  module Shared
+    def set_pagelet_options *args
+      opts = args.extract_options!
+      actions = args
+      actions << 'default' if actions.blank?
+
+      @pagelet_options ||= {}.with_indifferent_access
+
+      if opts.any?
+        actions.each do |action|
+          @pagelet_options.deep_merge! action => opts
+        end
+      end
+      @pagelet_options
+    end
+  end
+
+  module ClassMethods
+    include Shared
+
+    def pagelet_options *args
+      set_pagelet_options *args
+
+      if superclass && superclass.instance_variable_defined?(:@pagelet_options)
+        parent = superclass.instance_variable_get :@pagelet_options
+        parent.merge(@pagelet_options)
+      else
+        @pagelet_options
+      end
+    end
+
+    def inherited subklass
+      existing = subklass.ancestors.reverse.
+        reduce({}.with_indifferent_access) do |memo, ancestor|
+
+        if ancestor.instance_variable_defined?(:@pagelet_options)
+          memo.deep_merge! ancestor.instance_variable_get :@pagelet_options
+        end
+        memo
+      end
+
+      subklass.instance_variable_set(:@pagelet_options, existing)
+
+      super
+    end
+  end
+
+end

data/lib/pagelet_rails/concerns/placeholder.rb

@@ -0,0 +1,35 @@
+module PageletRails::Concerns::Placeholder
+  extend ActiveSupport::Concern
+
+  # This concern should be called after cache callback
+  # #process_action method does not give such order
+  # as it's called before callbacks
+  def send_action *args
+    render_remote_load
+    if !performed?
+      super
+    end
+  end
+
+  def render_remote_load
+    # puts 'render_remote_load'.blue
+    render_remotely = pagelet_render_remotely?
+    if render_remotely && pagelet_options.has_cache
+      render_remotely = false
+    end
+
+    return unless render_remotely
+
+    data = params.deep_dup
+    data.permit!
+
+    if pagelet_options.remote != :stream
+      pagelet_options html: { 'data-widget-url' => url_for(data) }
+    end
+
+    default_view = '/layouts/pagelet_rails/loading_placeholder'
+    view = pagelet_options.placeholder.try(:[], :view).presence || default_view
+
+    render view
+  end
+end

data/lib/pagelet_rails/concerns/response_wrapper.rb

@@ -0,0 +1,33 @@
+module PageletRails::Concerns::ResponseWrapper
+  extend ActiveSupport::Concern
+
+  def process_action *args
+    super.tap do
+      if params[:target_container] &&
+        action_has_layout? &&
+        request.format.js? # wrap to js only if requested js
+
+        response.content_type = 'text/javascript'
+
+        html = self.response_body.reduce('') { |memo, body|
+          memo << body
+          memo
+        }
+
+        if html.match /^\s*</
+          # the body could be javascript, make sure it's html before wrapping
+
+          id = ActionController::Base.helpers.escape_javascript params[:target_container]
+          js = ActionController::Base.helpers.escape_javascript html
+
+          html = ActionController::Base.helpers.raw(
+            "PageletRails.pageletArrived('#{id}', '#{js}');"
+          )
+
+          self.response_body = [html]
+        end
+      end
+    end
+  end
+
+end

data/lib/pagelet_rails/concerns/routes.rb

@@ -0,0 +1,83 @@
+module PageletRails::Concerns::Routes
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    # Define routes inline in controller
+    #
+    #     pagelet_routes do
+    #       resources :users
+    #     end
+    #
+    def pagelet_routes &block
+      @pagelet_routes << block
+    end
+
+    def pagelet_resources *args, &block
+      controller_name = self.controller_name
+      @pagelet_routes << Proc.new do
+        resources controller_name, *args, &block
+      end
+    end
+
+    def pagelet_resource *args, &block
+      controller_name = self.controller_name
+      opts = args.extract_options!
+      opts[:controller] ||= controller_name
+
+      @pagelet_routes << Proc.new do
+        resource controller_name, *args, opts, &block
+      end
+    end
+
+    # Define inline single route for the following method.
+    # It automatically adds :controller and :action names to the route
+    #
+    #     class PageletRails::Examples::ExamplesController
+    #       pageletlet_route :get, ''
+    #       def bingo
+    #       end
+    #     end
+    #
+    # will generate routes
+    #   Helper:            pagelets_examples_path
+    #   HTTP Verb:         GET
+    #   Path:              /pagelets/examples(.:format)
+    #   Controller#Action: pagelets/examples/examples#bingo
+    #
+    def pagelet_route *args
+      @pagelet_route << args
+    end
+
+    def method_added method_name
+      return unless @pagelet_route
+      @pagelet_route.each do |args|
+        options = args.extract_options!
+        options[:controller] ||= self.controller_name
+        options[:action] ||= method_name
+
+        @pagelet_routes << Proc.new do
+          scope path: options[:controller], as: options[:controller] do
+            self.send *args, options
+          end
+        end
+      end
+
+      @pagelet_route = []
+      super
+    end
+
+    def load_pagelet_routes! context
+      @pagelet_routes.each do |proc|
+        context.instance_eval &proc
+      end
+    end
+
+    def inherited subklass
+      subklass.instance_variable_set(:@pagelet_routes, [])
+      subklass.instance_variable_set(:@pagelet_route, [])
+      super
+    end
+  end
+end
+
+

data/lib/pagelet_rails/encryptor.rb

@@ -0,0 +1,49 @@
+class PageletRails::Encryptor
+
+  DEFAULT_SALT = '!@#Q156^tdSXggT0&*789++8&?_|T%\/++==RqE'
+
+  attr_reader :salt
+
+  def self.encode(data, opts = {})
+    self.new(opts).encode data
+  end
+
+  def self.decode(encrypted_data, opts = {})
+    self.new(opts).decode encrypted_data
+  end
+
+  def self.get_key secret, salt
+    @get_key_cache ||= {}
+    key = [secret, salt]
+
+    @get_key_cache[key] ||= ActiveSupport::KeyGenerator.new(secret).generate_key(salt)
+  end
+
+  def initialize(opts = {})
+    @salt = opts.fetch :salt, DEFAULT_SALT
+    @secret = opts[:secret]
+  end
+
+  def secret
+    @secret || Rails.application.secrets[:secret_key_base]
+  end
+
+  def encode(data)
+    encryptor.encrypt_and_sign(data)
+  end
+
+  def decode(encrypted_data)
+    encryptor.decrypt_and_verify(encrypted_data)
+  end
+
+  private
+
+  def encryptor
+    @encryptor ||= begin
+      key = self.class.get_key secret, salt
+
+      ActiveSupport::MessageEncryptor.new(key)
+    end
+  end
+
+end

data/lib/pagelet_rails/engine.rb

@@ -0,0 +1,4 @@
+module PageletRails
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/pagelet_rails/router.rb

@@ -0,0 +1,23 @@
+class PageletRails::Router
+
+  def self.load_routes! context
+    controllers = Dir[Rails.root.join('app', 'pagelets', '*', '*controller.rb')]
+
+    controllers.each do |controller_file|
+      pagelet_name = File.basename(File.dirname(controller_file))
+
+      basename_controller_name = File.basename controller_file, '.rb'
+      controller = "#{pagelet_name}/#{basename_controller_name}".camelize.constantize
+
+      next unless controller.respond_to? :load_pagelet_routes!
+
+      context.instance_eval do
+        scope module: pagelet_name, path: "/pagelets", as: "pagelets" do
+          controller.load_pagelet_routes! self
+        end
+      end
+
+    end
+  end
+
+end

data/lib/pagelet_rails/version.rb

@@ -0,0 +1,3 @@
+module PageletRails
+  VERSION = '0.1.0'
+end

data/lib/pagelet_rails.rb

@@ -0,0 +1,28 @@
+require "pagelet_rails/engine"
+require "pagelet_rails/version"
+
+require "action_controller/action_caching"
+
+
+module PageletRails
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :Encryptor
+    autoload :Router
+  end
+
+  module Concerns
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Cache
+      autoload :Controller
+      autoload :Options
+      autoload :Placeholder
+      autoload :ResponseWrapper
+      autoload :Routes
+    end
+  end
+
+end

data/lib/tasks/pagelet_rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :pagelet_rails do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: pagelet_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anton Katunin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Improve perceived performance of your rails application with minimum
+  effort
+email:
+- antulik@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/pagelet_rails_manifest.js
+- app/assets/javascripts/pagelet_rails.js
+- app/assets/javascripts/pagelet_rails/jquery.ajaxprogress.js
+- app/assets/javascripts/views/modal_dialog.jst.ejs
+- app/assets/javascripts/views/modal_dialog_iframe.jst.ejs
+- app/assets/javascripts/views/pagelet_load_failed.jst.ejs
+- app/assets/javascripts/views/pagelet_loading_overlay.jst.ejs
+- app/controllers/pagelet_controller.rb
+- app/controllers/pagelet_proxy_controller.rb
+- app/helpers/pagelets_helper.rb
+- app/views/layouts/pagelet_rails/container.html.slim
+- app/views/layouts/pagelet_rails/inner.slim
+- app/views/layouts/pagelet_rails/loading_placeholder.slim
+- config/routes.rb
+- lib/action_controller/action_caching.rb
+- lib/action_controller/caching/actions.rb
+- lib/pagelet_rails.rb
+- lib/pagelet_rails/concerns/cache.rb
+- lib/pagelet_rails/concerns/controller.rb
+- lib/pagelet_rails/concerns/options.rb
+- lib/pagelet_rails/concerns/placeholder.rb
+- lib/pagelet_rails/concerns/response_wrapper.rb
+- lib/pagelet_rails/concerns/routes.rb
+- lib/pagelet_rails/encryptor.rb
+- lib/pagelet_rails/engine.rb
+- lib/pagelet_rails/router.rb
+- lib/pagelet_rails/version.rb
+- lib/tasks/pagelet_rails_tasks.rake
+homepage: https://github.com/antulik/pagelet_rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Improve perceived performance of your rails application with minimum effort
+test_files: []