rack-prerender 1.6.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0455bf3050d53db38d75d2162014caf79f05526e89b754742a612c0dd29bde55
+  data.tar.gz: 34085238abec2b269ea584e02678d302b2fa69fd09ea4c2570490f481b804eb1
+SHA512:
+  metadata.gz: b30c8d6f9612ad4e7b98ed59f2ee51511a18e2d7bc92ff2a37b2a7fa40dca8d205af150fa30fe915de82b63fd8d66246dceb689d28b4814cc3a705200050c7ea
+  data.tar.gz: dae2fb0e2a877abebf84200b09318a15479459776a6496553ffd499e20a3e7d0d97ce0d23b04adbd5446d8273afbff34bf2d1e255519a5806876dc5f0e5b9952

data/lib/rack/prerender/constraint.rb

@@ -0,0 +1,122 @@
+module Rack
+  class Prerender
+    class Constraint
+      attr_reader :blacklist, :whitelist, :crawler_user_agents, :extensions_to_ignore
+
+      def initialize(opts = {})
+        @blacklist            = cast_to_regexp(opts[:blacklist], escape: false)
+        @whitelist            = cast_to_regexp(opts[:whitelist], escape: false)
+        @crawler_user_agents  = cast_to_regexp(opts[:crawler_user_agents] || CRAWLER_USER_AGENTS)
+        @extensions_to_ignore = cast_to_regexp(opts[:extensions_to_ignore] || EXTENSIONS_TO_IGNORE)
+      end
+
+      def matches?(env)
+        return false if env['REQUEST_METHOD'] != 'GET' ||
+                        env['HTTP_X_PRERENDER'] ||
+                        (user_agent = env['HTTP_USER_AGENT']).nil?
+
+        query = env['QUERY_STRING'].to_s
+        return false unless crawler_user_agents.match?(user_agent.downcase) ||
+                            env['HTTP_X_BUFFERBOT'] ||
+                            query.include?('_escaped_fragment_')
+
+        path = env['SCRIPT_NAME'].to_s + env['PATH_INFO'].to_s
+        fullpath = query.empty? ? path : "#{path}?#{query}"
+        return false if extensions_to_ignore.match?(fullpath)
+        return false if whitelist && !whitelist.match?(fullpath)
+        return false if blacklist && (blacklist.match?(fullpath) ||
+                                      blacklist.match?(env['HTTP_REFERER'].to_s.downcase))
+
+        true
+      end
+
+      private
+
+      def cast_to_regexp(list_arg, escape: true)
+        case list_arg
+        when Regexp, nil
+          list_arg
+        when Array
+          escape ? Regexp.union(list_arg) : Regexp.new(list_arg.join('|'))
+        else
+          Regexp.new(escape ? Regexp.escape(list_arg) : list_arg)
+        end
+      end
+
+      CRAWLER_USER_AGENTS = [
+        'applebot',
+        'baiduspider',
+        'bingbot',
+        'bitlybot',
+        'bufferbot',
+        'chrome-lighthouse',
+        'developers.google.com/+/web/snippet',
+        'discordbot',
+        'embedly',
+        'facebookexternalhit',
+        'flipboard',
+        'google page speed',
+        'googlebot',
+        'linkedinbot',
+        'nuzzel',
+        'outbrain',
+        'pinterest/0.',
+        'quora link preview',
+        'qwantify',
+        'redditbot',
+        'rogerbot',
+        'showyoubot',
+        'skypeuripreview',
+        'slackbot',
+        'tumblr',
+        'twitterbot',
+        'vkshare',
+        'w3c_validator',
+        'whatsapp',
+        'www.google.com/webmasters/tools/richsnippets',
+        'yahoo',
+      ]
+
+      EXTENSIONS_TO_IGNORE = %w[
+        .ai
+        .avi
+        .css
+        .dat
+        .dmg
+        .doc
+        .doc
+        .exe
+        .flv
+        .gif
+        .ico
+        .iso
+        .jpeg
+        .jpg
+        .js
+        .less
+        .m4a
+        .m4v
+        .mov
+        .mp3
+        .mp4
+        .mpeg
+        .mpg
+        .pdf
+        .png
+        .ppt
+        .psd
+        .rar
+        .rss
+        .swf
+        .tif
+        .torrent
+        .txt
+        .wav
+        .wmv
+        .xls
+        .xml
+        .zip
+      ]
+    end
+  end
+end

data/lib/rack/prerender/fetcher.rb

@@ -0,0 +1,98 @@
+module Rack
+  class Prerender
+    class Fetcher
+      attr_reader :env, :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def call(env)
+        cached_response = before_render(env)
+        return cached_response.finish if cached_response
+
+        if prerendered_response = fetch(env)
+          response = build_rack_response_from_prerender(prerendered_response)
+          after_render(env, prerendered_response)
+          return response.finish
+        end
+        nil
+      end
+
+      def before_render(env)
+        return unless callback = options[:before_render]
+
+        cached_render = callback.call(env)
+
+        if cached_render && cached_render.is_a?(String)
+          Rack::Response.new(cached_render, 200, { 'Content-Type' => 'text/html; charset=utf-8' })
+        elsif cached_render && cached_render.is_a?(Rack::Response)
+          cached_render
+        else
+          nil
+        end
+      end
+
+      def fetch(env)
+        url = URI.parse(api_url(env))
+        headers = {
+          'User-Agent'      => env['HTTP_USER_AGENT'],
+          'Accept-Encoding' => 'gzip'
+        }
+        headers['X-Prerender-Token'] = ENV['PRERENDER_TOKEN'] if ENV['PRERENDER_TOKEN']
+        headers['X-Prerender-Token'] = options[:prerender_token] if options[:prerender_token]
+        req = Net::HTTP::Get.new(url.request_uri, headers)
+        req.basic_auth(ENV['PRERENDER_USERNAME'], ENV['PRERENDER_PASSWORD']) if options[:basic_auth]
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true if url.scheme == 'https'
+        response = http.request(req)
+        if response['Content-Encoding'] == 'gzip'
+          response.body = ActiveSupport::Gzip.decompress(response.body)
+          response['Content-Length'] = response.body.length
+          response.delete('Content-Encoding')
+        end
+        response
+      rescue
+        nil
+      end
+
+      def api_url(env)
+        new_env = env
+        if env['CF-VISITOR']
+          match = /"scheme":"(http|https)"/.match(env['CF-VISITOR'])
+          new_env['HTTPS'] = true and new_env['rack.url_scheme'] = "https" and new_env['SERVER_PORT'] = 443 if (match && match[1] == 'https')
+          new_env['HTTPS'] = false and new_env['rack.url_scheme'] = "http" and new_env['SERVER_PORT'] = 80 if (match && match[1] == 'http')
+        end
+
+        if env['X-FORWARDED-PROTO']
+          new_env['HTTPS'] = true and new_env['rack.url_scheme'] = "https" and new_env['SERVER_PORT'] = 443 if env["X-FORWARDED-PROTO"].split(',')[0] == 'https'
+          new_env['HTTPS'] = false and new_env['rack.url_scheme'] = "http" and new_env['SERVER_PORT'] = 80 if env["X-FORWARDED-PROTO"].split(',')[0] == 'http'
+        end
+
+        if options[:protocol]
+          new_env['HTTPS'] = true and new_env['rack.url_scheme'] = "https" and new_env['SERVER_PORT'] = 443 if options[:protocol] == 'https'
+          new_env['HTTPS'] = false and new_env['rack.url_scheme'] = "http" and new_env['SERVER_PORT'] = 80 if options[:protocol] == 'http'
+        end
+
+        url = Rack::Request.new(new_env).url
+        prerender_url = prerender_service_url()
+        forward_slash = prerender_url[-1, 1] == '/' ? '' : '/'
+        "#{prerender_url}#{forward_slash}#{url}"
+      end
+
+      def prerender_service_url
+        options[:prerender_service_url] || ENV['PRERENDER_SERVICE_URL'] || 'http://service.prerender.io/'
+      end
+
+      def build_rack_response_from_prerender(prerendered_response)
+        response = Rack::Response.new(prerendered_response.body, prerendered_response.code, prerendered_response)
+        options[:build_rack_response_from_prerender].call(response, prerendered_response) if options[:build_rack_response_from_prerender]
+        response
+      end
+
+      def after_render(env, response)
+        (callback = options[:after_render]) && callback.call(env, response)
+      end
+    end
+  end
+end

data/lib/rack/prerender/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rack
+  class Prerender
+    VERSION = '1.6.2'
+  end
+end

data/lib/rack/prerender.rb

@@ -0,0 +1,20 @@
+module Rack
+  class Prerender
+    require 'net/http'
+    require_relative 'prerender/constraint'
+    require_relative 'prerender/fetcher'
+    require_relative 'prerender/version'
+
+    attr_reader :app, :constraint, :fetcher
+
+    def initialize(app, options = {})
+      @app        = app
+      @constraint = Constraint.new(options)
+      @fetcher    = Fetcher.new(options)
+    end
+
+    def call(env)
+      constraint.matches?(env) && fetcher.call(env) || app.call(env)
+    end
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: rack-prerender
+version: !ruby/object:Gem::Version
+  version: 1.6.2
+platform: ruby
+authors:
+- Todd Hooper
+- Janosch Müller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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: Rack middleware to prerender your javascript heavy pages on the fly (fork
+  of prerender_rails).
+email:
+- todd@prerender.io
+- janosch84@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack/prerender.rb
+- lib/rack/prerender/constraint.rb
+- lib/rack/prerender/fetcher.rb
+- lib/rack/prerender/version.rb
+homepage: https://github.com/jaynetics/rack-prerender
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Prerender your javascript rendered application on the fly when search engines
+  crawl
+test_files: []