embed_me 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c628ce31537a49b18079252bd49617f003742a93221a2ecbf2ba645738f9e7e
-  data.tar.gz: 46b44b37276d1405fb5de4d1ccb3f3820092a4f3ee920f9e69391190fda3e8d5
+  metadata.gz: eba667022e999ab1bc98f4321e5a54b4725ed38dc14ea829b89e22938b3d083b
+  data.tar.gz: 67ec8ebc91cc0902b41b1c3f51bffe5f556016a0984dfcfcc440aca29238d9b5
 SHA512:
-  metadata.gz: 0c579ab7593c3071b070ca29ec0960b99cc51396d623308b9f129737c2eca0a35be1b05174e8aa1687102ffdfac02cf54b1a7ba641cc784b00b193b746e51b8e
-  data.tar.gz: '007769ff6db0b0e7b9ef854fc1fa4e05e8f9bd0c122e932d80ae6b3b05aee11fd9108b214c05399fbd9fc9e4a66f84b414c502a79aa427a2747fc6b12576b5db'
+  metadata.gz: c6e25e412a79552e4cad0cb81d32813f7ebab05af3aa3dea241a0e38855bf3cadc5b1f2e0a830edd2b74aba81fe3903bfacb2284c5aee01d40009f8a49aa9689
+  data.tar.gz: 40fdf41e6dec1bbac477744f6e10b553e411a4b2e21235bd46f12c0c486bb113ec78588a796e37e1675b5f6142be912b2c0635599b6e81efba3f2267e968f03f

data/lib/embed_me.rb

@@ -1,4 +1,6 @@
 require "embed_me/engine"
+require "embed_me/link_helper"
+require "embed_me/code_generator"
 require "embed_me/rails/routes"
 
 module EmbedMe

data/lib/embed_me/code_generator.rb

@@ -0,0 +1,42 @@
+module EmbedMe
+  module CodeGenerator
+    include EmbedMe::LinkHelper
+
+    # Generates some HTML code that allows embedding of the resource of the current request.
+    # Creates an iframe element with the embed link as src attribute. HTML options can be
+    # customized. Returns a string.
+    #
+    # ==== Examples
+    # Assuming the current request is '/' (root):
+    #
+    #   embed_code()
+    #   # => "<iframe width="560" height="315" src="http://localhost:3000/embed" frameborder="0"
+    #       sandbox="">Your Browser does not support HTML iFrame Element.</iframe>"
+    #
+    #   embed_code(fallback: "")
+    #   # => "<iframe width="560" height="315" src="http://localhost:3000/embed" frameborder="0"
+    #       sandbox=""></iframe>"
+    #
+    #   embed_code(width: 760, height: 500)
+    #   # => "<iframe width="760" height="500" src="http://localhost:3000/embed" frameborder="0"
+    #       sandbox="">Your Browser does not support HTML iFrame Element.</iframe>"
+    #
+    #   embed_code(width: nil, height: nil)
+    #   # => "<iframe src="http://localhost:3000/embed" frameborder="0" sandbox="">Your Browser
+    #       does not support HTML iFrame Element.</iframe>"
+    def embed_code(options = {})
+      # get embed link or return if not present
+      embed_url = current_page_embed_url
+      return nil unless embed_url.present?
+
+      # set values
+      fallback = options.delete(:fallback) || "Your Browser does not support HTML iFrame Element."
+      default_html = {width: 560, height: 315, src: embed_url, frameborder: 0, sandbox: ''}
+      default_html.merge!(options)
+
+      # create element
+      element = content_tag(:iframe, fallback, default_html)
+      "#{element}"
+    end
+  end
+end

data/lib/embed_me/engine.rb

@@ -2,29 +2,32 @@ module EmbedMe
   class Engine < ::Rails::Engine
     isolate_namespace EmbedMe
 
-    initializer "embed_me" do
+    initializer 'embed_me' do
       ActiveSupport.on_load(:action_controller) do
         before_action :check_embedding!
+        helper_method :embedded?
+        helper EmbedMe::LinkHelper
+        helper EmbedMe::CodeGenerator
 
-        def default_url_options(options={})
-          hash_embed = Hash.new
-          hash_embed[EmbedMe.scope_name] = EmbedMe.scope_name.to_s
-          hash_normal = Hash.new
-          hash_normal[EmbedMe.scope_name] = nil
-          params[EmbedMe.scope_name] == EmbedMe.scope_name.to_s ? hash_embed : hash_normal
+        # Checks if the request comes from an embedded resource and removes the
+        # X-Frame-Options Header so that the content can be opened in a frame.
+        # If the request comes from a resource that is not intended to be embedded,
+        # the value remains, so that the frame blocks the rendering.
+        def check_embedding!
+          if embedded?
+            response.headers.except! 'X-Frame-Options'
+          end
         end
 
+        # Checks the path of the request for the existence of the embedded parameter,
+        # which is specified by the routes. If this value is available, the resource
+        # may be embedded. If the value is not available, the resource must not be
+        # embedded. URL parameters remain ignored. Returns a boolean value.
         def embedded?
           # using path instead of params because path[:embed] != params[:embed] if
           # URL: http://localhost:3000/posts?embed=embed
           path = Rails.application.routes.recognize_path(request.path)
-          path[EmbedMe.scope_name] == EmbedMe.scope_name.to_s
-        end
-
-        def check_embedding!
-          if embedded?
-            response.headers.except! 'X-Frame-Options'
-          end
+          path[:embedded].present?
         end
       end
     end

data/lib/embed_me/link_helper.rb

@@ -0,0 +1,115 @@
+module EmbedMe
+  module LinkHelper
+    # Creates an HTML link element. To do this, it checks whether the request comes
+    # from an embedded resource and whether there is an embedded version of the
+    # requested route. If both are true, a link is generated that redirects to the
+    # embedded version. If no embedded version of the route exists, but the request
+    # is within an embedding, the link will be opened in a new tab. If the request
+    # is not embedded, the link is created as normal.
+    #
+    # ==== Examples
+    # Assuming the current request is NOT embedded, then:
+    #
+    #   embeddable_link_to("Not Embeddable", private_path)
+    #   # => <a href="/private">Not Embeddable</a>
+    #
+    #   embeddable_link_to("Embeddable", embeddable_path)
+    #   # => <a href="/embeddable">Embeddable</a>
+    #
+    # Assuming the current request IS embedded, then:
+    #
+    #   embeddable_link_to("Not Embeddable", private_path)
+    #   # => <a target="_blank" href="/private">Not Embeddable</a>
+    #
+    #   embeddable_link_to("Embeddable", embeddable_path)
+    #   # => <a href="/embed/embeddable">Embeddable</a>
+    def embeddable_link_to(name = nil, options = nil, html_options = {}, &block)
+      if embedded? && embedded_link_available?(options)
+        # generate embedded link if possible
+        merged_params = merged_embedded(options)
+        link_to(name, merged_params, html_options, &block)
+      elsif embedded?
+        # open link in new tab if no embedded link available
+        html_options.merge!({target: "_blank"})
+        link_to(name, options, html_options, &block)
+      else
+        # normal behaviour if not embedded
+        link_to(name, options, html_options, &block)
+      end
+    end
+
+    # Checks whether there is an embedded version of a specific route.
+    # Returns a boolean Value.
+    #
+    # ==== Examples
+    #
+    #   embedded_link_available?(private_path)
+    #   # => false
+    #
+    #   embedded_link_available?(root_path)
+    #   # => true
+    #
+    #   embedded_link_available?(embed_posts_path)
+    #   # => true
+    def embedded_link_available?(url_data)
+      merged_params = merged_embedded(url_data)
+
+      # test if embedded flag is in path or url parameter
+      embedded_link = url_for(merged_params)
+      embedded_link_params = Rails.application.routes.recognize_path(embedded_link)
+      embedded_link_params[:embedded].present?
+    end
+
+    # Extracts the Route generation parameters and merges the embedded value,
+    # which is used to generate embedding specific URLs. Returns a hash containing
+    # url generation data.
+    #
+    # ==== Examples
+    #
+    #   merged_embedded(posts_path)
+    #   # => {:controller=>"posts", :action=>"index", :embedded=>true}
+    #
+    #   merged_embedded(controller: "posts", action: "index")
+    #   # => {:controller=>"posts", :action=>"index", :embedded=>true}
+    def merged_embedded(url_data)
+      # extract link parameters
+      original_link = url_for(url_data)
+      original_link_params = Rails.application.routes.recognize_path(original_link)
+
+      # merge embedded flag
+      merged_params = original_link_params.merge({embedded: true})
+      merged_params
+    end
+
+    # Checks if there is an embedded version for the current request. If this is the
+    # case, the link to the embedded version is returned. If there is no embedded
+    # version, nil is returned.
+    #
+    # ==== Examples
+    # Assuming the current request IS embeddable:
+    # (E.g. root_path)
+    #
+    #   current_page_embed_url()
+    #   # => http://localhost:3000/embed
+    #
+    # (E.g. post_path(id: 1))
+    #
+    #   current_page_embed_url()
+    #   # => http://localhost:3000/embed/posts/1
+    #
+    # Assuming the current request is NOT embeddable:
+    # (E.g. private_path)
+    #
+    #   current_page_embed_url()
+    #   # => nil
+    def current_page_embed_url
+      # return if no link available
+      return nil unless embedded_link_available?(request.path)
+
+      # get current link
+      current_page = merged_embedded(request.path)
+      current_page.merge!({only_path: false})
+      url_for(current_page)
+    end
+  end
+end

data/lib/embed_me/rails/routes.rb

@@ -1,7 +1,26 @@
 module ActionDispatch::Routing
   class Mapper
+    # Enables the definition of resources that should be embeddable. The routes defined
+    # within the block are transferred to the application in duplicated form. Once
+    # normally, as they would always work, and once under an embed scope. The name of
+    # the scope can be set in config (default: 'embed').
+    #
+    # ==== Examples
+    # Assuming the following route definition:
+    #
+    #   get 'path_private', to: 'application#path_private'
+    #   embeddable do
+    #     get 'path_embed', to: 'application#path_embed'
+    #   end
+    #
+    # will produce following routes:
+    #
+    #   path_private     GET   /path_private(.:format)        application#path_private
+    #   path_embed       GET   /path_embed(.:format)          application#path_embed
+    #   embed_path_embed GET   /embed/path_embed(.:format)    application#path_embed {:embedded=>true}
     def embeddable
-      scope "(:#{EmbedMe.scope_name.to_s})", embed: /#{EmbedMe.scope_name.to_s}/ do
+      yield
+      scope EmbedMe.scope_name.to_s, as: EmbedMe.scope_name.to_s, embedded: true do
         yield
       end
     end

data/lib/embed_me/version.rb

@@ -1,3 +1,3 @@
 module EmbedMe
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: embed_me
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Tobias Bohn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-16 00:00:00.000000000 Z
+date: 2021-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -44,20 +44,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: byebug
-  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: EmbedMe allows you and your users to easily embed your rails application
   or parts of it on other websites.
 email:
@@ -79,7 +65,9 @@ files:
 - app/views/layouts/embed_me/application.html.erb
 - config/routes.rb
 - lib/embed_me.rb
+- lib/embed_me/code_generator.rb
 - lib/embed_me/engine.rb
+- lib/embed_me/link_helper.rb
 - lib/embed_me/rails/routes.rb
 - lib/embed_me/version.rb
 - lib/tasks/embed_me_tasks.rake