editmode 1.2.1 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64a20fe2b3a8ccf1cd1dafc516a2484b6f4ce6701ecdd2d4f2b8a431137959bd
-  data.tar.gz: 683549e7c9085dda0d1ef74ff7e2b142fa746372c1da288af5e154017b69b957
+  metadata.gz: 84c4ada25fc650fcb7f2a9b9c8322562bda944bd1180815e60bf3f3ef7534d94
+  data.tar.gz: 246e38a66ff7fb77ca953ef0e222720defdc72447eac982bdf5e39c7c0b34a0f
 SHA512:
-  metadata.gz: 92953c97a18f6fb3b91389f4beab95ffc75f92bf91e4a603094a016c6673724c49442a46643259b0e9a9c4b48c855f9821eee7e19b7801cf2fca2b1d8c2cce4b
-  data.tar.gz: 3763c6e47edd0cd6c326a7cc80a0583b20d3a9db66d652b3416c643548a3356e45896846ea321b4a63f3b605e07a6f1df3dc6b8f070b63939d5b6b86fbb3c2a6
+  metadata.gz: 9c891c169c1759113a86a6cf8daa6f7910b676e5296b036784cf37a2dec35f6d82b3237d8284027ecb3bb6126c9e168de5dcbceedc8f6829161bd6a7b844cb25
+  data.tar.gz: a674897c9c9a1c5ef04f95fb378982343557dd14f03e4b5e55a6093cbf470b56ef663aa7c3bed30bb7e475c53b5a4ee3b1164143bc7e1e83e545cb8ef74feeac

data/README.md

@@ -50,6 +50,12 @@ Editmode provides helper methods for use in your rails views and controllers.
 <%= E('cnk_x4ts...', class: "a-css-class") %> # Render a chunk with inline css class 
 ```
 
+### Working with multiple projects in the same codebase
+If you want to include content from a different project to the one you've specified in the initializer, you can pass the project id in to the view helper.
+```erb
+<%= E("cnk_16e04a02d577afb610ce", project_id: "prj_02d577afb617hdb") %>
+```
+
 ### Content can also be accessed in Controllers
 ```ruby
 @page_title = e("cnk_x4ts............")  # Using a chunk identifier
@@ -78,6 +84,8 @@ e("cnk_16e04a02d577afb610ce", "Email Content", variables: variable_values)
 # Response: "Hi Dexter Morgan"
 ```
 
+
+
 ### Use collections for repeatable content
 ```erb
 <%= c('col_j8fbs...', class: "profiles-container", item_class: "profile-item") do %>

data/lib/editmode/action_view_extensions/editmode_helper.rb

@@ -56,14 +56,14 @@ module Editmode
                 chunks.each do |chunk|
                   @custom_field_chunk = chunk
                   concat(content_tag(:div, class: "chunks-collection-item--wrapper #{item_class}") do
-                    yield
+                    yield(@custom_field_chunk)
                   end)
                 end
 
                 # Placeholder element for new collection item
                 @custom_field_chunk = chunks.first.merge!({placeholder: true})
                 concat(content_tag(:div, class: "chunks-hide chunks-col-placeholder-wrapper") do
-                  yield
+                  yield(@custom_field_chunk)
                 end)
               end 
             else
@@ -80,9 +80,8 @@ module Editmode
       def chunk_field_value(parent_chunk_object, custom_field_identifier, options = {})
         begin 
           chunk_identifier = parent_chunk_object["identifier"]
-          custom_field_item = parent_chunk_object["content"].detect do |f|
-            f["custom_field_identifier"].try(:downcase) == custom_field_identifier.try(:downcase)  || f["custom_field_name"].try(:downcase)  == custom_field_identifier.try(:downcase)
-          end
+          chunk_value = Editmode::ChunkValue.new(parent_chunk_object["identifier"], options.merge({response: parent_chunk_object}))
+          custom_field_item = chunk_value.field_chunk(custom_field_identifier)
 
           options[:field] = custom_field_identifier
           
@@ -94,7 +93,7 @@ module Editmode
           if custom_field_item.present?
             render_chunk_content(
               custom_field_item["identifier"],
-              custom_field_item["content"],
+              chunk_value.field(custom_field_identifier),
               custom_field_item["chunk_type"],
               { parent_identifier: chunk_identifier, custom_field_identifier:  custom_field_identifier}.merge(options)
             )
@@ -106,12 +105,7 @@ module Editmode
       end
 
       def render_chunk_content(chunk_identifier, chunk_content, chunk_type,options = {})
-
         begin 
-          # Always sanitize the content!!
-          chunk_content = ActionController::Base.helpers.sanitize(chunk_content) unless chunk_type == 'rich_text'
-          chunk_content = variable_parse!(chunk_content, options[:variable_fallbacks], options[:variable_values])
-
           css_class = options[:class]
           cache_id = options[:cache_identifier]
 
@@ -126,6 +120,8 @@ module Editmode
           chunk_data.merge!({parent_identifier: options[:parent_identifier]}) if options[:parent_identifier].present?
           chunk_data.merge!({custom_field_identifier: options[:custom_field_identifier]}) if options[:custom_field_identifier].present?
           chunk_data.merge!({chunk_cache_id: cache_id}) if cache_id.present?
+          chunk_data.merge!({chunk_collection_identifier: options[:collection_id]}) if options[:collection_id].present?
+          chunk_data.merge!({chunk_content_key: options[:content_key]}) if options[:content_key].present?
 
           case display_type
           when "span"
@@ -150,61 +146,31 @@ module Editmode
       end
 
       def chunk_display(label, identifier, options = {}, &block)
-        branch_id = params[:em_branch_id]
+        options[:branch_id] = params[:em_branch_id] if params[:em_branch_id].present?
         # This method should never show an error. 
         # If anything goes wrong fetching content
         # We should just show blank content, not
         # prevent the page from loading.
         begin
-          branch_params = branch_id.present? ? "branch_id=#{branch_id}" : ""
           field = options[:field].presence || ""          
-          cache_identifier = "chunk_#{identifier}#{branch_id}#{field}"
-          url = "#{api_root_url}/chunks/#{identifier}?project_id=#{Editmode.project_id}&#{branch_params}"
-          cached_content_present = Rails.cache.exist?(cache_identifier)
-          parent_identifier = identifier if field.present?
-          if !cached_content_present
-            response = HTTParty.get(url)
-            response_received = true if response.code == 200
-          end
 
-          if !cached_content_present && !response_received
-            raise "No response received"
+          chunk_value = Editmode::ChunkValue.new(identifier, options)
+          
+          if field.present? && chunk_value.chunk_type == 'collection_item'
+            chunk_content = chunk_value.field(field)
+            identifier = chunk_value.field_chunk(field)["identifier"]
+            chunk_type = chunk_value.field_chunk(field)["chunk_type"]
+            options[:collection_id] = chunk_value.collection_id
           else
-            if field.present? && response.present?
-              field_content = response["content"].detect {|f| f["custom_field_identifier"].downcase == field.downcase || f["custom_field_name"].downcase == field.downcase }
-              if field_content
-                content = field_content["content"]
-                type = field_content["chunk_type"]
-                identifier = Rails.cache.fetch("#{cache_identifier}_field_identifier") do
-                  field_content["identifier"]
-                end
-              end
-            end
-
-            variable_fallbacks = Rails.cache.fetch("#{cache_identifier}_variables") do
-              response['variable_fallbacks'].presence || {}
-            end
-
-            chunk_content = Rails.cache.fetch(cache_identifier) do  
-              content.presence || response["content"]
-            end
-
-            chunk_type = Rails.cache.fetch("#{cache_identifier}_type") do  
-              type.presence || response['chunk_type']
-            end
-
-            identifier = Rails.cache.fetch("#{cache_identifier}_field_identifier") do
-              identifier
-            end
-
-            options[:variable_fallbacks] = variable_fallbacks
-            options[:variable_values] = options[:variables].presence || {}
-            
-            options[:cache_identifier] =  parent_identifier.presence || identifier
-            
-            render_chunk_content(identifier,chunk_content,chunk_type, options)
+            chunk_content = chunk_value.content
+            chunk_type = chunk_value.chunk_type
+            identifier = chunk_value.response["identifier"] unless identifier.include? "cnk_"
           end
 
+          options[:cache_identifier] = chunk_value.identifier
+          options[:content_key] = chunk_value.response.try(:[], "content_key")
+          render_chunk_content(identifier, chunk_content, chunk_type, options)
+
         rescue => error
           # Show fallback content by default
           return content_tag("em-span", &block) if block_given?
@@ -231,28 +197,6 @@ module Editmode
       end
       alias_method :E, :render_chunk
 
-
-      def variable_parse!(content, variables = {}, values = {}, raw = false)
-        tokens = content.scan(/\{{(.*?)\}}/)
-        if tokens.any?
-          tokens.flatten! 
-          tokens.each do |token|
-            token_value = values[token.to_sym] || variables[token] || ""
-            sanitized_value = ActionController::Base.helpers.sanitize(token_value)
-
-            unless raw
-              sanitized_value = content_tag("em-var", :data => {chunk_variable: token, chunk_variable_value: sanitized_value}) do
-                sanitized_value
-              end
-            end
-            
-            content.gsub!("{{#{token}}}", sanitized_value)
-          end
-        end
-
-        content
-      end
-
       def no_response_received(id = "")
         "Sorry, we can't find a chunk using this identifier: \"#{id}\". This can happen if you've deleted a chunk on editmode.com or if your local cache is out of date. If it persists, try running Rails.cache clear."
       end

data/lib/editmode/chunk_value.rb

@@ -1,29 +1,42 @@
 module Editmode
   class ChunkValue
-    include Editmode::ActionViewExtensions::EditmodeHelper
+    include ActionView::Helpers::TagHelper
+    include ActionView::Context
+
+    attr_accessor :identifier, :variable_values, :branch_id,
+      :variable_fallbacks, :chunk_type, :project_id,
+      :url, :collection_id, :cache_identifier,
+      :response
 
-    attr_accessor :identifier, :variable_values, :branch_id, 
-                  :variable_fallbacks, :chunk_type, :project_id,
-                  :response
-                  
     attr_writer :content
 
-    def initialize(identifier, **options)
+    def initialize(identifier, project_id: Editmode.project_id, **options)
       @identifier = identifier
       @branch_id = options[:branch_id].presence
+      @project_id = project_id
       @variable_values = options[:variables].presence || {}
-      get_content
+      @raw = options[:raw].present?
+      @skip_sanitize = options[:dangerously_skip_sanitization]
+
+      @url = "#{api_root_url}/chunks/#{identifier}"
+      @cache_identifier = set_cache_identifier(identifier)
+
+      if options[:response].present?
+        @response = options[:response]
+        set_response_attributes!
+      else
+        get_content
+      end
     end
 
-    def field(field = nil)      
+    def field(field = nil)
       # Field ID can be a slug or field_name
       if chunk_type == 'collection_item'
         if field.present?
-          field.downcase!
-          field_content = @content.detect {|f| f["custom_field_identifier"].downcase == field || f["custom_field_name"].downcase == field }
-          if field_content.present?
-            result = field_content['content']
-            result = variable_parse!(result, variable_fallbacks, variable_values, true)
+          field_chunk = field_chunk(field)
+          if field_chunk.present?
+            result = field_chunk['content']
+            result = variable_parse!(result, variable_fallbacks, variable_values, @raw, @skip_sanitize)
           else
             raise no_response_received(field)
           end
@@ -37,15 +50,29 @@ module Editmode
       result.try(:html_safe)
     end
 
+    def field_chunk(field)
+      field.downcase!
+      @content.detect {|f| f["custom_field_identifier"].downcase == field || f["custom_field_name"].downcase == field }
+    end
+
     def content
-      raise "undefined method 'content` for chunk_type: collection_item \nDid you mean? field" if chunk_type == 'collection_item'
-      
-      result = variable_parse!(@content, variable_fallbacks, variable_values, true)
+      raise "undefined method 'content' for chunk_type: collection_item \nDid you mean? field" if chunk_type == 'collection_item'
+
+      result = variable_parse!(@content, variable_fallbacks, variable_values, @raw, @skip_sanitize)
       result.try(:html_safe)
     end
 
     private
 
+    # Todo: Transfer to helper utils
+    def api_root_url
+      ENV["EDITMODE_OVERRIDE_API_URL"] || "https://api.editmode.com"
+    end
+
+    def set_cache_identifier(id)
+      "chunk_#{project_id}#{branch_id}#{id}"
+    end
+
     def json?(json)
       JSON.parse(json)
       return true
@@ -53,19 +80,46 @@ module Editmode
       return false
     end
 
-    def get_content
-      branch_params = branch_id.present? ? "branch_id=#{branch_id}" : ""
-      url = "#{api_root_url}/chunks/#{identifier}?project_id=#{Editmode.project_id}&#{branch_params}"
+    def variable_parse!(content, variables = {}, values = {}, raw = true, skip_sanitize=false)
+      content = ActionController::Base.helpers.sanitize(content) unless skip_sanitize
+      tokens = content.scan(/\{{(.*?)\}}/)
+      if tokens.any?
+        tokens.flatten!
+        tokens.each do |token|
+          token_value = values[token.to_sym] || variables[token] || ""
+          sanitized_value = ActionController::Base.helpers.sanitize(token_value)
 
-      cache_identifier = "chunk_value_#{identifier}#{branch_id}"
-      cached_content_present = Rails.cache.exist?(cache_identifier)
+          unless raw
+            sanitized_value = content_tag("em-var", :data => {chunk_variable: token, chunk_variable_value: sanitized_value}) do
+              sanitized_value
+            end
+          end
 
-      if !cached_content_present
-        http_response = HTTParty.get(url)
+          content.gsub!("{{#{token}}}", sanitized_value)
+        end
+      end
+
+      content
+    end
+
+    def cached?
+      Rails.cache.exist?(cache_identifier)
+    end
+
+    def query_params
+      the_params = { 'project_id' => project_id }
+      the_params['branch_id'] = branch_id if branch_id.present?
+
+      the_params
+    end
+
+    def get_content
+      if !cached?
+        http_response = HTTParty.get(url, query: query_params)
         response_received = true if http_response.code == 200
       end
 
-      if !cached_content_present && !response_received
+      if !cached? && !response_received
         raise no_response_received(identifier)
       else
         cached_response = Rails.cache.fetch(cache_identifier) do
@@ -73,13 +127,17 @@ module Editmode
         end
 
         @response = json?(cached_response) ? JSON.parse(cached_response) : cached_response
+        set_response_attributes!
+      end
+    end
 
-        @content = response['content']
-        @chunk_type = response['chunk_type']
-        @project_id = response['project_id']
-        @variable_fallbacks = response['variable_fallbacks'].presence || {}
-      end      
+    def set_response_attributes!
+      @content = response['content']
+      @chunk_type = response['chunk_type']
+      @variable_fallbacks = response['variable_fallbacks'].presence || {}
+      @collection_id = response["collection"]["identifier"] if chunk_type == 'collection_item'
+      @branch_id = response['branch_id']
     end
 
   end
-end
+end

data/lib/editmode/helper.rb

@@ -4,20 +4,37 @@ module Editmode
     def e(identifier, *args)
       field, options = parse_arguments(args)
       begin
-        chunk = Editmode::ChunkValue.new(identifier, options)
-
-        if chunk.chunk_type == 'collection_item'
-          chunk.field(field)
-        else
-          chunk.content
-        end 
+        chunk = Editmode::ChunkValue.new(identifier, options.merge({raw: true}))
+        render_noneditable_chunk(chunk, field, options)
       rescue => er
         puts er
       end
     end
 
+    def render_noneditable_chunk(chunk, field=nil, options=nil)
+      return render_collection_item(chunk, field, options) if chunk.chunk_type == 'collection_item'
+
+      render_content(chunk, options)
+    end
+
+    def render_collection_item(chunk, field=nil, options=nil)
+      return render_image(chunk.field(field), options[:class]) if chunk.field_chunk(field)['chunk_type'] == 'image'
+
+      chunk.field(field)
+    end
+
+    def render_content(chunk, options=nil)
+      return render_image(chunk.content, options[:class]) if chunk.chunk_type == 'image'
+
+      chunk.content
+    end
+
+    def render_image(content, css_class=nil)
+      image_tag(content, class: css_class)
+    end
+
     def render_custom_field_raw(label, options={})
-      e(@custom_field_chunk["identifier"], label, options)
+      e(@custom_field_chunk["identifier"], label, options.merge({response: @custom_field_chunk}))
     end
     alias_method :f, :render_custom_field_raw
 
@@ -33,4 +50,4 @@ module Editmode
       return field, options
     end
   end
-end
+end

data/lib/editmode/version.rb

@@ -1,3 +1,3 @@
 module Editmode
-  VERSION = "1.2.1"
+  VERSION = "1.2.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: editmode
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.6
 platform: ruby
 authors:
 - Tony Ennis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-23 00:00:00.000000000 Z
+date: 2020-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler