render_turbo_stream 3.0.4 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 536c9b9d2d37a6767f7134dea0a9a5d19e268dc2b15dd1fec52b6d29b9db99b1
-  data.tar.gz: 294c01ceb4e7370050350d49d85f68a9acc09ca435c70a945dcde9abf81108e0
+  metadata.gz: 525e9a802269d71e60be6cbc44fe62ebbe677a89fd49e048b1dbc11c6ae4d2b0
+  data.tar.gz: 5b47c7b9a7dcc49491e4ab20eb2637654b62e971afe0abdf481ec9210e97f145
 SHA512:
-  metadata.gz: 63e368ad4d85f001693395a66057e1229297e7332a5d2ac8bdf785fa1ec7042511a4d2ee491394dd11ebf6ac2dace4091f70a4b62945f43ec23d002ac9b6d4d6
-  data.tar.gz: 4c5c9758b9a063071219765a74d033f32d77fe4e3fd713ed95ec993334c71670d5694a36293a5acb8074a6e0ae6e8e677ca098cd1db78fb8fcc8e3c5eb52d014
+  metadata.gz: c532c3c9a5307547f260ff1feefea8e43b3cb09e42c43eacad1771c8a72b16a9843703024e1a58891a0498592c53dd296f2a6d7ef0dac72554c838c7c42d3915
+  data.tar.gz: f1c5cf8193d9c3214d60c492d73e7ebaf844b848dfa88a602ee235af9c0fbe90d757584938cf3b58d661d507b119791d4fe544968580654406c63abdfe4c1864

data/README.md

@@ -1,8 +1,14 @@
 # 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.
+TTo say it up front: If you want to have all the benefits of Turbo without disturbing the handy default Rails workflow, you have to use WebSockets, 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.
+
+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. This gem checks if a partial has the necessary frames, wraps it, and includes a helper to make instance variables work for Turbo Streams as well. This way, a simple as-usual partial is compatible for withh and without turbo, and can be sent in any way.
+
+It has a testing strategy!
+
+A lot of details for handling many different ways of redirect, that are possible and necessary since Turbo, are handled.
 
 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`.
 
@@ -11,10 +17,10 @@ Logic to Ruby, views to views, and the space in between for the gem! And all thi
 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.
 
+April 2023 first released this gem is in a very early state. I am happy if others contribute for increase the quality of this new kind of working with rails 7.
+
 **Chris**
 
 ## Installation
@@ -49,24 +55,29 @@ 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.use_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.
+
 The corresponding partials for flashes could look [like this](https://gitlab.com/sedl/renderturbostream/-/wikis/Flashes-example)
 
 **Translations**
 
 ```
-activerecord.success.successfully_created
-activerecord.success.successfully_updated
-activerecord.errors.messages.could_not_create
-activerecord.errors.messages.could_not_update
+en:
+  activerecord:
+    success:
+      successfully_created: '%<model_name>s successfully created'
+      successfully_updated: '%<model_name>s successfully updated'
+    errors:
+      messages:
+        could_not_create: '%<model_name>s could not be created'
+        could_not_update: '%<model_name>s could not be updated'
 ```
 
-example value: `"%<model_name>s successfully created"`
-
 Model name translations, see: Rails Docs.
 
 **Turbo power**
@@ -90,20 +101,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',
@@ -114,6 +124,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
@@ -149,90 +161,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).
-
-There are two workarounds:
-
-```ruby
-config.x.render_turbo_stream.use_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.
+**Config: allow_channel_to_me_for_turbo_stream_save**
 
-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:
+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
-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
 ```
 
@@ -242,25 +199,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 = available_instance_variables
+      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