render_turbo_stream 3.0.5 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c984de11f7923f03531f0b53b0a4224bd3c56520f75bc4e92e16292c9e2a9e86
-  data.tar.gz: 184129722f704f61599a022f3ef6bb7306c3b7d1f74a5770a666cac9835e5839
+  metadata.gz: caa22ab0fcd032899bc52bb3e92bc576e26bea6bb187acbe0e00b3162e78c054
+  data.tar.gz: 7314b1bb2199fb89fc83df166c5a02749c82b291ab0210ababbf1afffedfb72a
 SHA512:
-  metadata.gz: 5983031570c67f03c85ae84341d51bfd6cbb76f2f1e5b1543f2434cc6d133edbcdbd25205c6162b55bdacaa7531c79a411f397c65695598b76096e1395c54182
-  data.tar.gz: e672f2427971215dada8b1b3b6047a6331e0c0e39f7c1b5166f2fe2992e35cbc03dc94fb7d39abcc2f1091d20f650d3b0ad6b2720fa4f66b4476810b2865785f
+  metadata.gz: a99d072daf0c5cfb3955790ba17aa63ddbabdd7332ced553f06abb988ad5150329f1a787da4d03b58d34b088398d6ec64b3774fde34b429f46837e13ac11418a
+  data.tar.gz: 6d16c9a72c015961e6597847d664806871f550088b0a54f8a4e4f0c0df186844de4ca1838159fcfe8243f76de0c8ca53fa0513aa688c7e091db5d648491b4d8b

data/README.md

@@ -1,19 +1,23 @@
 # RenderTurboStream
 
-DHH made a milestone in web development with [Rails 7, "Fulfilling a Vision"](https://rubyonrails.org/2021/12/15/Rails-7-fulfilling-a-vision). This gem is my contribution to that bold new step. The goal is to have a complete rails like workflow.
+2021 DHH annouced a great milestone in web development with [Rails 7, "Fulfilling a Vision"](https://rubyonrails.org/2021/12/15/Rails-7-fulfilling-a-vision).
 
-Defining templates like `(create|update).turbo_stream.haml` annoyed me. Because it is a heavy mix of logic and view. Working consistently with turbo_stream or Turbo Streams Channel means shooting a lot of partials from the backend to the frontend. And there are many ways and tedious details to handle redirects since Turbo! This can all be streamlined.
+To say it up front: If you want to have all the benefits of Turbo without disturbing the handy default Rails workflow, you must use WebSockets sometimes, which are well integrated in Turbo, see [README Turbo::StreamsChannel](https://gitlab.com/sedl/renderturbostream/-/blob/main/README-channels.md). But the starting point is here. And I recommend that you download my [Quick-and-dirty test project](https://gitlab.com/sedl/renderturbostream_railsapp), set it up, see all the tests succeed, and then read through this README.
 
-Execute [turbo_power](https://github.com/marcoroth/turbo_power) commands such as adding a css class to an html element, pushing a state to the browser history, or running custom javascript actions through Turbo Stream can be written in pure ruby code. No need for embeds like `.html.erb`.
+Defining templates like `(create|update).turbo_stream.haml` is a heavy mix of logic and view. This gem separates logic and view so that `*.turbo_stream.*` templates are no longer necessary and the logic can stay on the ruby side.
 
-Logic to Ruby, views to views, and the space in between for the gem! And all this together with a testing strategy for the Ruby side.
+For `:replace` actions, responses must be wrapped inside a `turbo_frame_tag` with a matching `target_id`. The gem will regex the content and wrap it by a `turbo_frame_tag` if necessary but not present. This way the matching `target_id` is only defined in one place. This check only happens on the first call after restarting the application in production and on every call if precompile assets is set to true in configs.
+
+There are many different ways to handle **redirects** since turbo. The gem brings this into a workflow.
+
+Execute [turbo_power](https://github.com/marcoroth/turbo_power) commands such as adding a css class to an html element, can be sent directly from the controller.
+
+Has a testing strategy.
 
 An overview of how we design a rails-7 application with turbo
 is [published on dev.to](https://dev.to/chmich/rails-7-vite-wrapping-up-1pia).
 
-A quick and dirty application with all the features, including built in tests is [here](https://gitlab.com/sedl/renderturbostream_railsapp).
-
-Hope it can help you.
+I am happy if it can help.
 
 **Chris**
 
@@ -49,9 +53,9 @@ Required Configurations for Flash Partial
 
 ```ruby
     config.x.render_turbo_stream.flash_partial = 'layouts/flash'
-    config.x.render_turbo_stream.flash_id = 'flash-box'
-    config.x.render_turbo_stream.flash_action = 'prepend'
-    config.x.render_turbo_stream.allow_channel_for_turbo_stream_save = true
+    config.x.render_turbo_stream.flash_target_id = 'flash-box'
+    config.x.render_turbo_stream.flash_turbo_action = 'prepend'
+    config.x.render_turbo_stream.allow_channel_to_me_for_turbo_stream_save = true
 ```
 
 For the latter you have to setup channels, see below.
@@ -95,20 +99,19 @@ The Rails team has integrated `ActionCable` as `Turbo::StreamsChannel` into `Tur
 def update
   turbo_stream_save(
     @article.update(article_params),
-    turbo_redirect_on_success_to: (params['no_redirection'] == 'true' ? nil : articles_path),
-    id: 'form'
+    if_success_turbo_redirect_to: articles_path,
+    target_id: 'customer-form'
   )
 end
 ```
-
-This will set a status, generate a flash message and perform `render_turbo_stream`, which would, if update succeeded result in something like this:
+This will set a status, generate a flash message, and run `render_turbo_stream`. If it fails, it would result in something like this:
 
 ```ruby
 render_turbo_stream(
   [
     {
       id: 'customer-form',
-      partial: 'customers/form'
+      partial: 'customers/customer_form'
     },
     {
       id: 'flash-wrapper',
@@ -119,6 +122,8 @@ render_turbo_stream(
 )
 ```
 
+If the update succeeds, it will do a `redirect_to` action from turbo_power
+
 The `stream_partial` method is for rendering a partial alone.
 
 ```ruby
@@ -154,90 +159,35 @@ render_turbo_stream(
 
 Under the hood, inside a `*.turbo_stream.erb` template, it does the following: `= turbo_stream.send args.first, *(args[1..-1])`
 
-**WORKAROUNDS for redirects inside frame**
-
-Suppose you have a CRUD controller that should do all its actions inside a turbo frame. Classic redirect_to, together with a turbo_stream action on the same response, would raise «Render and/or redirect were called multiple times in this action». See [issue](https://gitlab.com/sedl/renderturbostream/-/issues/3).
+**Config: allow_channel_to_me_for_turbo_stream_save**
 
-There are two workarounds:
+Turbo streams rely on the controller response, which can only be executed once for a request. Other than Turbo::StreamsChannel, they cannot run in parallel with the standard responses like redirect_to.
 
-```ruby
-config.x.render_turbo_stream.allow_channel_for_turbo_stream_save = true
-```
-
-With this config, the `turbo_stream_save` method will send flash messages through `Turbo::StreamsChannel` (if installed as described above) to a channel to the currently logged in user in parallel with the redirect.
-
-Another workaround is to use the src attribute of the parent frame. `turbo_frame_set_src` comes from turbo_power. The code might look like this:
-
-```ruby
-def update
-    turbo_stream_save(
-      @car.update(car_params),
-      streams_on_success: [
-        [
-          :turbo_frame_set_src,
-          'cars-box',
-          cars_path
-        ]
-      ]
-    )
-  end
-
-```
-
-**Parameters for turbo_stream_save**
-
-    save_action,
-    redirect_on_success_to: nil, # does a regular redirect. Works if you are inside a turbo_frame and just want to redirect inside that frame BUT CANNOT STREAM OTHERS ACTIONS ON THE SAME RESPONSE https://github.com/rails/rails/issues/48056
-    turbo_redirect_on_success_to: nil, # does a full page redirect (break out of all frames by turbo_power redirect)
-    object: nil, # object used in save_action, example: @customer
-    id: nil, # if nil: no partial is rendered
-    partial: nil, # example: 'customers/form' default: "#{controller_path}/#{id}"
-    action: 'replace', # options: append, prepend
-    locals: {}, # locals used by the partial
-    streams_on_success: [
-      {
-        id: nil,
-        partial: 'form',
-        locals: {},
-        action: 'replace'
-      }
-    ], # additional partials that should be rendered if save_action succeeded
-    streams_on_error: [
-      {
-        id: nil,
-        partial: 'form',
-        locals: {},
-        action: 'replace'
-      }
-    ], # additional partials that should be rendered if save_action failed
-    add_flash_alerts: [], #=> array of strings
-    add_flash_notices: [], #=> array of strings
-    flashes_on_success: [], #=> array of strings
-    flashes_on_error: [] #=> array of strings
+If this config is set to true, Turbo::StreamsChannel is installed and a current user is logged in:
 
+If an `if_success_redirect_to` argument is provided and the save action was successful, `turbo_stream_save` would send the partials by channel.
 
 # Testing
 
-For system testing there is Capybara. Its the only way to check if frontend and backend work together. But its a good practice to break tests into smaller pieces. The much larger number of tests we will write on the much faster request tests, examples here in rspec.
-
-**request tests cannot test javascript. they only test the ruby side: check if the right content is sent to turbo**.
+To test if the whole system works together, including javascript actions, so that finally a part reaches the surface, there is **Capybara** system testing. But it is a good practice to **break tests into smaller pieces**. So, there are helpers for **enabling the much faster request tests that are much easier to maintain**.
 
 If the request format is not `turbo_stream`, which is the case on request specs, the method responds in a special html
 that contains the medadata that is interesting for our tests and is parsed by included test helpers. 
 
 There is a helper for writing the test: In the debugger, within the test, check the output of `all_turbo_responses`.
 
-Test scenarios are:
+**Response Status**
 
-**The fastest**
-
-If you want to check if a controller action succeeded, just check for `response.status`. The `turbo_stream_save` method returns three statuses: `200` if `save_action` is true, otherwise `422` and `302` for redirect. If one of the declared partials does not exist or breaks, the server will respond with exception anyway.
+The `turbo_stream_save` method sets three statuses to the response: `200` if `save_action` is true, otherwise `422` and `302` for redirect. If one of the declared partials does not exist or breaks, the server will respond with exception anyway.
 
 **Redirection**
+
+If you defined the attribute `if_success_turbo_redirect_to` which uses the redirect_to function from `turbo_power` if installed:
+
 ```ruby
-  it 'update success' do
+it 'update success' do
   patch article_path(article, params: valid_params)
-  expect(turbo_redirect_to).to eq(articles_path)
+  assert_turbo_redirect_to('/articles')
 end
 ```
 
@@ -247,25 +197,17 @@ end
 expect(turbo_targets.length).to eq(2)
 # Check the total number of targeted html-ids, in most cases it will be one form and one flash.
 
+assert_stream_action('turbo_frame_set_src'){ |args| args == ["cars-box", "/cars"] }
+# if the turbo_power gem is installed
+
 assert_stream_response('form'){|e|e.css('.field_with_errors').inner_html.include?('title')}
 # make sure that there is one response to the target '#form' and it checks the rendered content
 # if cero or more responses are expected, add a attribute like 'count: 0'
 ```
 
-Possible matchers can be found at [Nokogiri](https://nokogiri.org/tutorials/searching_a_xml_html_document.html).
-
-The `assert_stream_response`, like the other matchers, checks by default that the same target is not affected multiple times by the `:replace` action within the same response. This is defined in the underlying `RenderTurboStream::Test::Request::Libs.select_responses` method, which is also used for the `assert_channel_to_*` methods.
-
-```ruby
-# check actions from turbo_power gem
-assert_stream_response('colored-element', action: 'remove_css_class') {|args| args.last == 'background-red' }
-# block (all within {}) is optional
-```
-
-**P.S.:**
+Possible matchers for checking html content can be found at [Nokogiri](https://nokogiri.org/tutorials/searching_a_xml_html_document.html).
 
-Testing the plugin itself: There is a [quick-and-dirty app](https://gitlab.com/sedl/renderturbostream_railsapp) which
-includes the plugin and has tests done by rspec/request and capybara.
+The `assert_stream_response` checks by default that the same target is not affected multiple times by the `:replace` action within the same response. This is defined in the underlying `RenderTurboStream::Test::Request::Libs.select_responses` method, which is also used for the `assert_channel_to_*` methods.
 
 # More Configs
 

data/app/views/layouts/_add_turbo_frame_tag.html.erb

@@ -0,0 +1,6 @@
+<%= turbo_frame_tag local_assigns[:render_turbo_stream_target_id] do %>
+  <%# locs = { value: 'hi' } %>
+  <%# locs2 = local_assigns.to_h %>
+  <%#= render local_assigns[:render_turbo_stream_partial], locals: { article: 'hi' } %>
+  <%= yield %>
+<% end %>

data/app/views/render_turbo_stream.turbo_stream.erb

@@ -12,12 +12,21 @@
 
 
   <% else %>
-    <% ctl = { partial: args[:partial], id: args[:id], action: args[:action] } %>
-    <% info = { id: args[:id], partial: args[:partial], locals: args[:locals] } %>
+    <% ctl = { partial: args[:partial], target_id: args[:target_id], action: args[:action] } %>
+    <% info = { target_id: args[:target_id], partial: args[:partial], locals: args[:locals] } %>
+
+
+
     <% if args[:action].present? %>
       <% Rails.logger.debug("  • render-turbo-stream #{args[:action].upcase} => #{info}") %>
-      <%= turbo_stream.send args[:action].to_sym, args[:id] do %>
-        <%= render args[:partial], locals: args[:locals]&.symbolize_keys %>
+      <%= turbo_stream.send args[:action].to_sym, RenderTurboStream::Libs.target_to_target_id(args[:target]) do %>
+        <% if RenderTurboStream::CheckTemplate.new(partial: args[:partial], action: args[:action]).add_turbo_frame_tag? %>
+          <%= turbo_frame_tag RenderTurboStream::Libs.target_to_target_id(args[:target]) do %>
+            <%= render args[:partial], locals: args[:locals]&.symbolize_keys %>
+          <% end %>
+        <% else %>
+          <%= render args[:partial], locals: args[:locals]&.symbolize_keys %>
+        <% end %>
       <% end %>
 
     <% else %>

data/app/views/render_turbo_stream_request_test.html.erb

@@ -6,14 +6,22 @@
   <% if s.is_a?(Array) %>
     <% attr_id = RenderTurboStream::Test::Request::Libs.first_arg_is_html_id(s.first) %>
     <% h = { array: s, type: 'stream-command', action: s.first } %>
-    <% h[:target] = "##{s.second[0]=='#' ? s.second[1..-1] : s.second}" if attr_id %>
+    <% h[:target] = "##{s.second[0] == '#' ? s.second[1..-1] : s.second}" if attr_id %>
     <% rendered_partials.push(h) %>
   <% else %>
-    <% html = (render s[:partial], locals: s[:locals]&.symbolize_keys, formats: [:html]) %>
-    <% s.delete(:partial) %>
-    <% s[:target] = "##{s[:id]}" %>
+
+    <% wrap = RenderTurboStream::CheckTemplate.new(partial: s[:partial], action: s[:action]).add_turbo_frame_tag? %>
+
+    <% if wrap %>
+      <% html = turbo_frame_tag RenderTurboStream::Libs.target_to_target_id(s[:target]) do %>
+        <%= (render s[:partial], locals: s[:locals]&.symbolize_keys, formats: [:html]) %>
+      <% end %>
+    <% else %>
+      <% html = (render s[:partial], locals: s[:locals]&.symbolize_keys, formats: [:html]) %>
+    <% end %>
+    <% s[:target] = s[:target] %>
     <% s.delete(:id) %>
-    <% rendered_partials.push({ html_response: html, type: 'partial' }.merge(s)) %>
+    <% rendered_partials.push({ html_response: html, type: 'stream-partial' }.merge(s)) %>
   <% end %>
 
 

data/lib/render_turbo_stream/channel_libs.rb

@@ -1,16 +1,48 @@
 module RenderTurboStream
   class ChannelLibs
 
-    def self.render_to_channel(response, channel, target_id, action, partial: nil, template: nil, locals: nil)
+    def initialize(response)
+      @response = response
+    end
+
+    def render_to_channel(channel, target, action, controller_self, partial: nil, template: nil, locals: nil)
+
+      # instance variables
+
+      target_id = RenderTurboStream::Libs.target_to_target_id(target)
+      check_template = RenderTurboStream::CheckTemplate.new(
+        partial: partial,
+        template: template,
+        available_instance_variables: controller_self.instance_variables,
+        action: action
+      )
+
+      # add instance_variables to locals
 
       locals = {} unless locals # prevent error missing keys for nil
+      if check_template.add_turbo_frame_tag?
+        _layout = 'layouts/add_turbo_frame_tag'
+        _locals = locals.merge(
+          {
+            render_turbo_stream_partial: partial,
+            render_turbo_stream_target_id: target_id
+          }
+        )
+      else
+        _locals = locals
+        _layout = false
+      end
+      check_template.templates_instance_variables.each do |v|
+        _locals[:"render_turbo_stream_instance_variable_#{v}"] = controller_self.instance_variable_get(v.to_s)
+      end
 
       # add headers for test
+
       if Rails.env.test?
-        html = RenderTurboStreamRenderController.render(partial: partial, locals: locals) if partial
-        html = RenderTurboStreamRenderController.render(template: template, locals: locals) if template
+        html = RenderTurboStreamRenderController.render(partial: partial, locals: _locals, layout: _layout) if partial
+        html = RenderTurboStreamRenderController.render(template: template, locals: _locals, layout: _layout) if template
         props = {
-          target: "##{target_id}",
+          target: target,
           action: action,
           type: 'channel-partial',
           locals: locals,
@@ -20,12 +52,12 @@ module RenderTurboStream
 
         props[:partial] = partial if partial
         props[:template] = template if template
-        h = response.headers.to_h
+        h = @response.headers.to_h
         i = 1
         loop do
           k = "test-turbo-channel-#{i}"
           unless h.keys.include?(k)
-            response.headers[k] = props.to_json
+            @response.headers[k] = props.to_json
             break
           end
           i += 1
@@ -40,8 +72,8 @@ module RenderTurboStream
           channel.to_s,
           target: target_id,
           partial: partial,
-          locals: locals&.symbolize_keys,
-          layout: false
+          locals: _locals&.symbolize_keys,
+          layout: _layout
         )
       elsif template
         Turbo::StreamsChannel.send(
@@ -50,12 +82,12 @@ module RenderTurboStream
           target: target_id,
           template: template,
           locals: locals&.symbolize_keys,
-          layout: false
+          layout: _layout
         )
       end
     end
 
-    def self.action_to_channel(response, channel, command, arguments)
+    def action_to_channel(channel, command, arguments)
 
       if Rails.env.test?
 
@@ -67,15 +99,15 @@ module RenderTurboStream
         }
         if RenderTurboStream::Test::Request::Libs.first_arg_is_html_id(command)
           target_id = (arguments.first[0..0] == '#' ? arguments.first[1..-1] : arguments.first)
-          props[:target] = "##{target_id}"
+          props[:target] = RenderTurboStream::Libs.target_id_to_target(target_id)
         end
-        
-        h = response.headers.to_h
+
+        h = @response.headers.to_h
         i = 1
         loop do
           k = "test-turbo-channel-#{i}"
           unless h.keys.include?(k)
-            response.headers[k] = props.to_json
+            @response.headers[k] = props.to_json
             break
           end
           i += 1
@@ -90,5 +122,17 @@ module RenderTurboStream
       )
     end
 
+    def send_actions_to_channel(channel, actions, instance_variables)
+      actions.each do |a|
+        if a.is_a?(Array)
+          action_to_channel(channel, a.first, a[1..-1])
+        else
+          render_to_channel(channel, a[:target], a[:action], instance_variables, partial: a[:partial], template: a[:template], locals: a[:locals])
+        end
+      end
+    end
+
+    def self.fetch_partials_variables(relative_path) end
+
   end
 end

data/lib/render_turbo_stream/channel_view_helpers.rb

@@ -32,5 +32,13 @@ module RenderTurboStream
       end
     end
 
+    def fetch_instance_variables(locals)
+      locals.each do |k,v|
+        if k[0..38] == 'render_turbo_stream_instance_variable_@'
+          eval "#{k[38..-1]} = v"
+        end
+      end
+    end
+
   end
 end

data/lib/render_turbo_stream/check_template.rb

@@ -0,0 +1,122 @@
+module RenderTurboStream
+  class CheckTemplate
+
+    AUTO_ADD_TURBO_FRAME_TAG_ON_ACTION = [:replace]
+
+    def initialize(partial: nil, template: nil, available_instance_variables: nil, action: nil)
+      if !partial && !template
+        raise 'missing attribute partial xor template'
+      end
+      unless action
+        raise 'missing required attribute: action'
+      end
+      @action = action
+      @partial_path = partial
+      @template_path = template
+      @available_instance_variables = nil #available_instance_variables #=> because if an instance variable was not set on production and the first call, and it was set on a later call, the gem would not know that and not set it.
+      prt = (partial ? partial : template).split('/')
+      if prt.length < 2
+        raise 'Partial or template path must always be specified with the controller path, for example «articles/partial_name».'
+      end
+      @controller_path = prt[0..-2].join('/')
+      @key = relative_path(partial: partial, template: template)
+      if production?
+        $render_turbo_stream_check_templates ||= {}
+        if $render_turbo_stream_check_templates[@key]
+          @result = $render_turbo_stream_check_templates[@key]
+        else
+          @result = { instance_variables: [], add_turbo_frame_tag: false }
+          fetch_nested_partials(1, partial: @partial_path, template: @template_path)
+          $render_turbo_stream_check_templates[@key] ||= @result
+        end
+      else
+        @result = { instance_variables: [], add_turbo_frame_tag: false }
+        fetch_nested_partials(1, partial: @partial_path, template: @template_path)
+      end
+    end
+
+    def templates_instance_variables
+      @result[:instance_variables]
+    end
+
+    def add_turbo_frame_tag?
+      @result[:add_turbo_frame_tag]
+    end
+
+    private
+
+    def production?
+      # in production this config should be set to true
+      !Rails.application.config.assets.compile
+    end
+
+    def fetch_nested_partials(stack_level, partial: nil, template: nil)
+
+      @nested_partials_done ||= []
+      if @nested_partials_done.include?(partial || template)
+        return # prevent endless loops
+      end
+      @nested_partials_done.push(partial || template)
+      absolute_path = absolute_path(partial: partial, template: template)
+      code = File.read(absolute_path)
+
+      _code = code.dup
+      _code.scan(/@[a-z_]+/).each do |var|
+        if !@available_instance_variables || (@available_instance_variables && @available_instance_variables.include?(var.to_sym))
+          unless @result[:instance_variables].include?(var.to_sym)
+            @result[:instance_variables].push(var.to_sym)
+          end
+        end
+      end
+
+      if stack_level == 1 && AUTO_ADD_TURBO_FRAME_TAG_ON_ACTION.include?(@action.to_sym)
+        unless _code.match(/(turbo_frame_tag|turbo-frame)/)
+          @result[:add_turbo_frame_tag] = true
+        end
+      end
+
+      loop do
+        _matched_partial = _code.match((/\brender[ ](partial:|())(|[ ])("|')[a-z_\/]+("|')/))
+        _code = _code[(_code.index(_matched_partial.to_s) + 5)..-1]
+        if _matched_partial
+
+          found_partial = _matched_partial.to_s.split(/("|')/)[-2]
+          absolute_path = absolute_path(partial: found_partial)
+
+          @nested_partials ||= []
+          @nested_partials.push(absolute_path)
+          fetch_nested_partials(stack_level += 1, partial: found_partial)
+
+        else
+          break
+        end
+      end
+      renders = code.match((/\brender[ ](partial:|())(|[ ])("|')[a-z_\/]+("|')/)) # scan function didnt  work here, so built a loop
+    end
+
+    def absolute_path(partial: nil, template: nil)
+      divided = relative_path(partial: partial, template: template).split('/')
+      view_folder = divided[0..-2].join('/')
+      folder = Rails.root.join('app', 'views', view_folder)
+      items = Dir.glob "#{folder.to_s}/*"
+      item = items.select { |i| i.split('/').last.match(/^#{divided.last}/) }.first
+      unless item.present?
+        raise "#{partial ? 'Partial' : 'Template'} not found => #{relative_path(partial: partial, template: template)}"
+      end
+      item
+    end
+
+    def relative_path(partial: nil, template: nil)
+      divided = (partial ? partial : template).split('/')
+      if divided.length <= 1
+        _divided = [@controller_path] + divided
+      else
+        _divided = divided
+      end
+      view_folder = _divided[0..-2].join('/')
+      file = "#{partial ? '_' : ''}#{divided.last}"
+      [view_folder, file].join('/')
+    end
+
+  end
+end