editmode 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2b0dd9951ef0e48376081729783e5f722f291818ce523db1867a7e6ecc30eb83
+  data.tar.gz: b83d8a8b26ce25c881fe848197917d0318fc5c32cab12105a14263e1cac78900
+SHA512:
+  metadata.gz: 4c9c3b5e77d2a30f30986009c9998c2746d38c9c95668ff05425ca006d0356728c049395ef7661c8d2158e68f1e2867a3a16b4b43f4643b0a42f830c02bdfce1
+  data.tar.gz: ae797ecca5f90c38ce43f5aa8cafa8ca39890ff336a441969065ea12e41f5b441057cd4454894462657eb23698508cb01f1e3948259d09f0f438710cc66a8c99

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chunks.gemspec
+gemspec

data/README.md

@@ -0,0 +1,20 @@
+
+# Editmode Rails Gem
+
+To be completed
+
+## Installation
+
+## How It Works
+- Autoload editmode.js
+- Expose view helper
+
+## Helper methods
+- chunk_display
+- raw_chunk
+- chunk_list (coming soon)
+
+## Caching
+- All chunks cached by default using Rails.cache
+- GET /editmode/clear_cache?identifier={} to clear cache
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/app/controllers/editmode_controller.rb

@@ -0,0 +1,21 @@
+class EditmodeController < ApplicationController
+
+  def clear_cache
+    if params[:full]
+      Rails.cache.clear
+      render status: 200, json: {:response => "success"}
+    elsif params[:variable_cache_project_id]
+      project_id = params[:variable_cache_project_id]
+      Rails.cache.delete("chunk_#{project_id}_variables")
+      render status: 200, json: {:response => "success"}
+    elsif params[:identifier]
+      Rails.cache.delete("chunk_#{params[:identifier]}")
+      Rails.cache.delete("chunk_#{params[:identifier]}_type")
+      render status: 200, json: {:response => "success"}
+    else
+      render status: 404, json: {:response => "no identifier specified"}
+    end
+
+  end
+
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+Rails.application.routes.draw do
+  # Use a namespaced url because /:generic can easily be overwritten by app default routes
+  get "/editmode/clear_cache" => "editmode#clear_cache" , :as => :editmode_clear_cache
+  # Support older route structure. To be expired
+  get "/chunksapp/clear_cache" => "editmode#clear_cache" , :as => :chunksapp_clear_cache
+end

data/lib/editmode.rb

@@ -0,0 +1,52 @@
+require "active_support/dependencies"
+require "editmode/version"
+require 'editmode/script_tag'
+require 'editmode/action_view_extensions/editmode_helper'
+require 'editmode/auto_include_filter'
+require 'editmode/chunk_value'
+require 'editmode/railtie' if defined? Rails
+require 'editmode/engine' if defined?(Rails)
+# Todo: Implement RSPEC
+module Editmode
+  class << self
+    include Editmode::ActionViewExtensions::EditmodeHelper
+
+    def project_id=(id)
+      config.project_id = id
+    end
+
+    def project_id
+      config.project_id
+    end
+
+    def access_token
+      config.access_token
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def setup
+      yield config
+    end
+
+    def chunk_value(identifier, **options)
+      begin
+        Editmode::ChunkValue.new(identifier, **options )
+      rescue => er
+        raise er
+      end
+    end
+  end
+
+  class Configuration
+    attr_accessor :access_token, :variable
+    attr_reader :project_id
+
+    def project_id=(id)
+      @project_id = id
+
+    end
+  end
+end

data/lib/editmode/action_view_extensions/editmode_helper.rb

@@ -0,0 +1,176 @@
+module Editmode
+  module ActionViewExtensions
+    module EditmodeHelper
+
+      require 'httparty'
+
+      def api_version
+        # Todo Add Header Version
+      end
+
+      def api_root_url
+        ENV["EDITMODE_OVERRIDE_API_URL"] || "https://api.editmode.com"
+      end
+
+      def chunk_collection(collection_identifier, **options)
+        branch_params = params[:em_branch_id].present? ? "branch_id=#{params[:em_branch_id]}" : ""
+        branch_id = params[:em_branch_id].presence
+        tags = options[:tags].presence || []
+        limit = options[:limit].presence
+
+        begin 
+          url_params = { 
+            :collection_identifier => collection_identifier,
+            :branch_id => branch_id,
+            :limit => limit,
+            :tags => tags
+          }.to_query
+
+          url = URI(api_root_url)
+          url.path = '/chunks'
+          url.query = url_params
+
+          response = HTTParty.get(url)
+
+          raise "No response received" unless response.code == 200
+          chunks = response["chunks"]
+
+          return chunks
+        rescue => error
+          puts error 
+          return []
+        end
+      end
+
+      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 {|f| f["custom_field_identifier"] == custom_field_identifier }
+        
+          if custom_field_item.present?
+            render_chunk_content(
+              custom_field_item["identifier"],
+              custom_field_item["content"],
+              custom_field_item["chunk_type"],
+              { parent_identifier: chunk_identifier }.merge(options)
+            )
+          end
+        rescue => errors
+          puts errors
+          content_tag(:span, "&nbsp".html_safe) 
+        end
+      
+      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'
+
+          css_class = options[:class]
+
+          if chunk_type == "image"
+            display_type = "image"
+          else 
+            display_type = options[:display_type] || "span"
+          end
+
+          chunk_data = { :chunk => chunk_identifier, :chunk_editable => false, :chunk_type => chunk_type }
+
+          if options[:parent_identifier].present?
+            chunk_data.merge!({parent_identifier: options[:parent_identifier]})
+          end
+
+          case display_type
+          when "span"
+            if chunk_type == "rich_text"
+              content = content_tag("em-span", :class => "editmode-richtext-editor #{css_class}", :data => chunk_data.merge!({:chunk_editable => true}) ) do
+                chunk_content.html_safe
+              end
+            else
+              content_tag("em-span", :class => css_class, :data => chunk_data.merge!({:chunk_editable => true}) ) do
+                chunk_content
+              end
+            end
+          when "image"
+            image_tag(chunk_content, :data => chunk_data, :class => css_class) 
+          end
+        rescue => errors
+          puts errors
+          content_tag("em-span", "&nbsp".html_safe) 
+        end
+
+      end
+
+      def chunk_display(label,identifier,options={},&block)
+        branch_id = params[:em_branch_id]
+        # 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}" : ""
+          cache_identifier = "chunk_#{identifier}#{branch_id}"
+          url = "#{api_root_url}/chunks/#{identifier}?#{branch_params}"
+          cached_content_present = Rails.cache.exist?(cache_identifier)
+
+          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"
+          else
+            
+            chunk_content = Rails.cache.fetch(cache_identifier) do  
+              response['content']
+            end
+
+            chunk_type = Rails.cache.fetch("#{cache_identifier}_type") do  
+              response['chunk_type']
+            end
+
+            render_chunk_content(identifier,chunk_content,chunk_type, options)
+
+          end
+
+        rescue => error
+          # Show fallback content by default
+          return content_tag("em-span", &block) if block_given?
+          # Otherwise show a span with no content to 
+          # maintain layout
+          content_tag("em-span", "&nbsp".html_safe) 
+        end
+
+      end
+
+      alias_method :chunk, :chunk_display
+
+      def variable_parse!(content, variables, values)
+        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)
+
+            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
+      
+      def require_field_id
+        "Field ID or Field Name is required to retrieve a collection item"
+      end
+    end
+  end
+end

data/lib/editmode/auto_include_filter.rb

@@ -0,0 +1,65 @@
+module Editmode
+
+  module AutoInclude
+
+    module Method
+      def editmode_auto_include
+        Editmode::AutoInclude::Filter.filter(self)
+      end
+    end
+
+    class Filter
+
+      CLOSING_BODY_TAG = %r{</body>}
+      def self.filter(controller)
+        auto_include_filter = new(controller)
+        return unless auto_include_filter.include_javascript?
+
+        auto_include_filter.include_javascript!
+      end
+
+      attr_reader :controller
+
+      def initialize(kontroller)
+        @controller = kontroller
+      end
+
+      def include_javascript!
+        response.body = response.body.gsub(CLOSING_BODY_TAG, editmode_script_tag.output + '\\0')
+      end
+
+      def include_javascript?
+        enabled_for_environment? &&
+        html_content_type? &&
+        response_has_closing_body_tag? &&
+        editmode_script_tag.valid?
+      end
+
+      private
+      def response
+        controller.response
+      end
+
+      def html_content_type?
+        response.content_type.try(:include?,'text/html')
+      end
+
+      def response_has_closing_body_tag?
+        !!(response.body[CLOSING_BODY_TAG])
+      end
+
+      def editmode_script_tag
+        @script_tag ||= Editmode::ScriptTag.new()
+      end
+
+      def enabled_for_environment?
+        enabled_environments = ["production","development","staging"]
+        return true if enabled_environments.nil?
+        enabled_environments.map(&:to_s).include?(Rails.env)
+      end
+
+    end
+
+  end
+
+end

data/lib/editmode/chunk_value.rb

@@ -0,0 +1,75 @@
+module Editmode
+  class ChunkValue
+    include Editmode::ActionViewExtensions::EditmodeHelper
+
+    attr_accessor :identifier, :variable_values, :branch_id, 
+                  :variable_fallbacks, :chunk_type, :project_id, 
+                  :response
+
+    attr_writer :content
+
+    def initialize(identifier, **options)
+      @identifier = identifier
+      @branch_id = options[:branch_id].presence
+      @variable_values = options[:values].presence || {}
+      get_content
+    end
+
+    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)
+          else
+            raise no_response_received(field)
+          end
+        else
+          raise require_field_id
+        end
+      else
+        raise NoMethodError.new "undefined method 'field` for chunk_type: #{chunk_type} \n"
+      end
+      result ||= content
+    end
+
+    def content
+      raise NoMethodError.new "undefined method 'content` for chunk_type: collection_item \nDid you mean? field" if chunk_type == 'collection_item'
+      
+      variable_parse!(@content, variable_fallbacks, variable_values)
+    end
+
+    private
+    def get_content
+      branch_params = branch_id.present? ? "branch_id=#{branch_id}" : ""
+      url = "#{api_root_url}/chunks/#{identifier}?#{branch_params}"
+
+      cache_identifier = "chunk_value_#{identifier}#{branch_id}"
+      cached_content_present = Rails.cache.exist?(cache_identifier)
+
+      if !cached_content_present
+        http_response = HTTParty.get(url)
+        response_received = true if http_response.code == 200
+      end
+
+      if !cached_content_present && !response_received
+        raise no_response_received(identifier)
+      else
+        @response = Rails.cache.fetch(cache_identifier) do
+          http_response
+        end
+
+        @content = response['content']
+        @chunk_type = response['chunk_type']
+        @project_id = response['project_id']
+        @variable_fallbacks = Rails.cache.fetch("chunk_#{project_id}_variables") do
+          response['variable_fallbacks']
+        end
+      end      
+    end
+
+  end
+end

data/lib/editmode/engine.rb

@@ -0,0 +1,8 @@
+module Editmode
+
+  class Engine < Rails::Engine
+
+  
+  end
+
+end

data/lib/editmode/railtie.rb

@@ -0,0 +1,19 @@
+module Editmode
+  class Railtie < Rails::Railtie
+    initializer "editmode" do |app|
+
+      ActiveSupport.on_load :action_view do
+        include Editmode::ActionViewExtensions::EditmodeHelper
+      end
+      ActiveSupport.on_load :action_controller do
+        include AutoInclude::Method
+
+        if respond_to? :after_action
+          after_action :editmode_auto_include
+        else
+          after_filter :editmode_auto_include
+        end
+      end
+    end
+  end
+end

data/lib/editmode/script_tag.rb

@@ -0,0 +1,35 @@
+module Editmode
+
+  class ScriptTag
+
+    def self.generate(*args)
+      new(*args).output
+    end
+
+    def initialize(options = {})
+      
+    end
+
+    def valid?
+      true
+    end
+
+    def output
+      
+      str = <<-EDITMODE_SCRIPT
+  <script>window.chunksProjectIdentifier = '#{Editmode.project_id}'</script>
+  <script>window.editmodeENV = '#{ENV["EDITMODE_ENV"] || 'production'}'</script>
+  <script src="#{script_url}" async ></script>
+      EDITMODE_SCRIPT
+
+      str.respond_to?(:html_safe) ? str.html_safe : str
+
+    end
+
+    def script_url 
+      ENV["EDITMODE_OVERRIDE_SCRIPT_URL"] || "https://static.editmode.com/editmode@^1.0.0/dist/editmode.js"
+    end
+
+  end
+
+end

data/lib/editmode/version.rb

@@ -0,0 +1,3 @@
+module Editmode
+  VERSION = "1.1.1"
+end

data/lib/generators/editmode/config_generator.rb

@@ -0,0 +1,26 @@
+
+require 'rails/generators/base'
+
+module Editmode
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      argument :project_id, :desc => "Your Editmode project_id, which can be found here: https://www.editmode.com/projects"
+
+      def create_config_file
+        @project_id = project_id
+        
+        introduction = <<-intro
+Editmode will automatically insert its javascript before the closing '</body>'
+tag on every page.
+
+        intro
+
+        print "#{introduction} "
+
+        template "editmode.rb.erb", "config/initializers/editmode.rb"
+      end
+    end
+  end
+end

data/lib/generators/editmode/templates/editmode.rb.erb

@@ -0,0 +1,5 @@
+Editmode.setup do |config|
+  # Replace TodoProjectId with your Editmode Project ID, 
+  # visit https://editmode.com/projects
+  config.project_id = "<%= @project_id %>"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: editmode
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Tony Ennis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  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: httparty
+  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: redcarpet
+  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'
+description: The Editmode gem allows you to include chunks from the Editmode platform
+  in your rails views
+email:
+- ennis.tony@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- app/controllers/editmode_controller.rb
+- config/routes.rb
+- lib/editmode.rb
+- lib/editmode/action_view_extensions/editmode_helper.rb
+- lib/editmode/auto_include_filter.rb
+- lib/editmode/chunk_value.rb
+- lib/editmode/engine.rb
+- lib/editmode/railtie.rb
+- lib/editmode/script_tag.rb
+- lib/editmode/version.rb
+- lib/generators/editmode/config_generator.rb
+- lib/generators/editmode/templates/editmode.rb.erb
+homepage: https://github.com/tonyennis145/editmode-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: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Editmode allows you to turn plain text in your rails app into easily inline-editable
+  bits of content that can be managed by anyone with no technical knowledge
+test_files: []