RubyGems - hanami-view - Versions diffs - 0.0.0 → 0.6.0 - Mend

hanami-view 0.0.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +96 -0
data/LICENSE.md +22 -0
data/README.md +826 -7
data/hanami-view.gemspec +17 -12
data/lib/hanami-view.rb +1 -0
data/lib/hanami/layout.rb +142 -0
data/lib/hanami/presenter.rb +126 -0
data/lib/hanami/view.rb +259 -2
data/lib/hanami/view/configuration.rb +464 -0
data/lib/hanami/view/dsl.rb +346 -0
data/lib/hanami/view/errors.rb +47 -0
data/lib/hanami/view/escape.rb +180 -0
data/lib/hanami/view/inheritable.rb +54 -0
data/lib/hanami/view/rendering.rb +265 -0
data/lib/hanami/view/rendering/layout_finder.rb +128 -0
data/lib/hanami/view/rendering/layout_registry.rb +63 -0
data/lib/hanami/view/rendering/layout_scope.rb +240 -0
data/lib/hanami/view/rendering/null_layout.rb +52 -0
data/lib/hanami/view/rendering/null_template.rb +83 -0
data/lib/hanami/view/rendering/partial.rb +29 -0
data/lib/hanami/view/rendering/partial_finder.rb +73 -0
data/lib/hanami/view/rendering/registry.rb +128 -0
data/lib/hanami/view/rendering/scope.rb +88 -0
data/lib/hanami/view/rendering/template.rb +67 -0
data/lib/hanami/view/rendering/template_finder.rb +53 -0
data/lib/hanami/view/rendering/template_name.rb +37 -0
data/lib/hanami/view/rendering/templates_finder.rb +129 -0
data/lib/hanami/view/rendering/view_finder.rb +37 -0
data/lib/hanami/view/template.rb +43 -0
data/lib/hanami/view/version.rb +4 -1
metadata +91 -16
data/.gitignore +0 -9
data/Gemfile +0 -4
data/Rakefile +0 -2
data/bin/console +0 -14
data/bin/setup +0 -8

data/lib/hanami/view/rendering/layout_scope.rb ADDED

@@ -0,0 +1,240 @@
+require 'hanami/utils/escape'
+module Hanami
+  module View
+    module Rendering
+      # Scope for layout rendering
+      #
+      # @since 0.1.0
+      class LayoutScope < BasicObject
+        # Initialize the scope
+        #
+        # @param layout [Hanami::Layout] the layout to render
+        # @param scope [Hanami::View::Rendering::Scope] the scope of the current
+        #   view
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(layout, scope)
+          @layout, @scope = layout, scope
+        end
+        # Returns the classname as string
+        #
+        # @return classname
+        #
+        # @since 0.3.0
+        def class
+          (class << self; self end).superclass
+        end
+        # Returns an inspect String
+        #
+        # @return [String] inspect String (contains classname, objectid in hex, available ivars)
+        #
+        # @since 0.3.0
+        def inspect
+          base = "#<#{ self.class }:#{'%x' % (self.object_id << 1)}"
+          base << " @layout=\"#{@layout.inspect}\"" if @layout
+          base << " @scope=\"#{@scope.inspect}\"" if @scope
+          base << ">"
+        end
+        # Render a partial or a template within a layout template.
+        #
+        # @param options [Hash]
+        # @option options [String] :partial the partial template to render
+        # @option options [String] :template the template to render
+        #
+        # @return [String] the output of the rendering process
+        #
+        # @since 0.1.0
+        #
+        # @example Rendering partial
+        #   # Given a partial under:
+        #   #   templates/shared/_sidebar.html.erb
+        #   #
+        #   # In the layout template:
+        #   #   templates/application.html.erb
+        #   #
+        #   # Use like this:
+        #   <%= render partial: 'shared/sidebar' %>
+        #
+        # @example Rendering template
+        #   # Given a template under:
+        #   #   templates/articles/index.html.erb
+        #   #
+        #   # In the layout template:
+        #   #   templates/application.html.erb
+        #   #
+        #   # Use like this:
+        #   <%= render template: 'articles/index' %>
+        #
+        # @example Rendering partial, using optional :locals
+        #   # Given a partial under:
+        #   #   templates/shared/_sidebar.html.erb
+        #   #
+        #   # In the layout template:
+        #   #   templates/application.html.erb
+        #   #
+        #   # Use like this:
+        #   <%= render partial: 'shared/sidebar', { user: current_user } %>
+        #
+        #   #
+        #   # `user` will be available in the scope of the sidebar rendering
+        def render(options)
+          renderer(options).render
+        end
+        # Returns the requested format.
+        #
+        # @return [Symbol] the requested format (eg. :html, :json, :xml, etc..)
+        #
+        # @since 0.1.0
+        def format
+          @scope.format
+        end
+        # The current view.
+        #
+        # @return [Hanami::View] the current view
+        #
+        # @since 0.1.0
+        def view
+          @view || @scope.view
+        end
+        # The current locals.
+        #
+        # @return [Hash] the current locals
+        #
+        # @since 0.1.0
+        def locals
+          @locals || @scope.locals
+        end
+        # Returns a content for the given key, by trying to invoke on the current
+        # scope, a method with the same name.
+        #
+        # The scope is made of locals and concrete methods from view and layout.
+        #
+        # @param key [Symbol] a method to invoke within current scope
+        # @return [String,NilClass] returning content if scope respond to the
+        #   requested method
+        #
+        # @since 0.4.1
+        #
+        # @example
+        #   # Given the following layout template
+        #
+        #   <!doctype HTML>
+        #   <html>
+        #     <!-- ... -->
+        #     <body>
+        #       <!-- ... -->
+        #       <%= content :footer %>
+        #     </body>
+        #   </html>
+        #
+        #   # Case 1:
+        #   #   Products::Index doesn't respond to #footer, content will return nil
+        #   #
+        #   # Case 2:
+        #   #   Products::Show responds to #footer, content will send back
+        #   #     #footer returning value
+        #
+        #   module Products
+        #     class Index
+        #       include Hanami::View
+        #     end
+        #
+        #     class Show
+        #       include Hanami::View
+        #
+        #       def footer
+        #         "contents for footer"
+        #       end
+        #     end
+        #   end
+        def content(key)
+          __send__(key) if respond_to?(key)
+        end
+        # Implements "respond to" logic
+        #
+        # @return [TrueClass,FalseClass]
+        #
+        # @since 0.3.0
+        #
+        # @see http://ruby-doc.org/core/Object.html#method-i-respond_to-3F
+        def respond_to?(m, include_all = false)
+          respond_to_missing?(m, include_all)
+        end
+        # Implements "respond to" logic
+        #
+        # @return [TrueClass,FalseClass]
+        #
+        # @since 0.3.0
+        # @api private
+        #
+        # @see http://ruby-doc.org/core/Object.html#method-i-respond_to_missing-3F
+        def respond_to_missing?(m, include_all)
+          @layout.respond_to?(m, include_all) ||
+            @scope.respond_to?(m, include_all)
+        end
+        protected
+        # Forward all the missing methods to the view scope or to the layout.
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::View::Rendering::Scope
+        # @see Hanami::Layout
+        #
+        # @example
+        #   # In the layout template:
+        #   #   templates/application.html.erb
+        #   #
+        #   # Use like this:
+        #   <title><%= article.title %></title>
+        #
+        #   # `article` will be looked up in the view scope first.
+        #   # If not found, it will be searched within the layout.
+        def method_missing(m, *args, &blk)
+          if @scope.respond_to?(m)
+            @scope.__send__(m, *args, &blk)
+          elsif layout.respond_to?(m)
+            layout.__send__(m, *args, &blk)
+          else
+            ::Hanami::View::Escape.html(super)
+          end
+        end
+        def renderer(options)
+          if options[:partial]
+            Rendering::Partial
+          elsif options[:template]
+            Rendering::Template
+          end.new(view, _options(options))
+        end
+        private
+        def _options(options)
+          options.dup.tap do |opts|
+            opts.merge!(format: format)
+            opts[:locals] = locals
+            opts[:locals].merge!(options.fetch(:locals){ ::Hash.new })
+          end
+        end
+        # @since 0.4.2
+        # @api private
+        def layout
+          @layout || @layout.class.layout.new(@scope, "")
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/null_layout.rb ADDED

@@ -0,0 +1,52 @@
+module Hanami
+  module View
+    module Rendering
+      # Null Object pattern for Layout.
+      # It's used when a view doesn't require a layout.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/view'
+      #
+      #   module Articles
+      #     class Show
+      #       include Hanami::View
+      #       layout false
+      #     end
+      #   end
+      #
+      #   # In this scenario we will use a `NullLayout`.
+      class NullLayout
+        # Initialize a layout
+        #
+        # @param scope [Hanami::View::Rendering::Scope] view rendering scope
+        # @param rendered [String] the output of the view rendering process
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::Layout#initialize
+        # @see Hanami::View::Rendering#render
+        def initialize(scope, rendered)
+          @rendered = rendered
+        end
+        # Render the layout
+        #
+        # @return [String] the output of the rendering process
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::Layout#render
+        # @see Hanami::View::Rendering#render
+        def render
+          @rendered
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/null_template.rb ADDED

@@ -0,0 +1,83 @@
+module Hanami
+  module View
+    module Rendering
+      # Null Object pattern for layout template
+      #
+      # It's used when a layout doesn't have an associated template.
+      #
+      # A common scenario is for non-html requests.
+      # Usually we have a template for the application layout
+      # (eg `templates/application.html.erb`), but we don't use to have the a
+      # template for JSON requests (eg `templates/application.json.erb`).
+      # Because most of the times, we only return the output of the view.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/view'
+      #
+      #   # We have an ApplicationLayout (views/application_layout.rb):
+      #   class ApplicationLayout
+      #     include Hanami::Layout
+      #   end
+      #
+      #   # Our layout has a template for HTML requests, located at:
+      #   # templates/application.html.erb
+      #
+      #   # We set it as global layout
+      #   Hanami::View.layout = :application
+      #
+      #   # We have two views for HTML and JSON articles.
+      #   # They have a template each:
+      #   #
+      #   #   * templates/articles/show.html.erb
+      #   #   * templates/articles/show.json.erb
+      #   module Articles
+      #     class Show
+      #       include Hanami::View
+      #       format :html
+      #     end
+      #
+      #     class JsonShow < Show
+      #       format :json
+      #     end
+      #   end
+      #
+      #   # We initialize the framework
+      #   Hanami::View.load!
+      #
+      #
+      #
+      #   # When we ask for a HTML rendering, it will use `Articles::Show` and
+      #   # ApplicationLayout. The output will be a composition of:
+      #   #
+      #   #   * templates/articles/show.html.erb
+      #   #   * templates/application.html.erb
+      #
+      #   # When we ask for a JSON rendering, it will use `Articles::JsonShow`
+      #   # and ApplicationLayout. Since, the layout doesn't have any associated
+      #   # template for JSON, the output will be a composition of:
+      #   #
+      #   #   * templates/articles/show.json.erb
+      class NullTemplate
+        # Render the layout template
+        #
+        # @param scope [Hanami::View::Scope] the rendering scope
+        # @param locals [Hash] a set of objects available during the rendering
+        # @yield [Proc] yields the given block
+        #
+        # @return [String] the output of the rendering process
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::Layout#render
+        # @see Hanami::View::Rendering#render
+        def render(scope, locals = {})
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/partial.rb ADDED

@@ -0,0 +1,29 @@
+require 'hanami/view/rendering/partial_finder'
+module Hanami
+  module View
+    module Rendering
+      # Rendering partial
+      #
+      # It's used when a template wants to render a partial.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::View::Rendering::Template
+      # @see Hanami::View::Rendering::LayoutScope#render
+      #
+      # @example
+      #   # We have an application template (templates/application.html.erb)
+      #   # that uses the following line:
+      #
+      #   <%= render partial: 'shared/sidebar' %>
+      class Partial < Template
+        protected
+        def template
+          PartialFinder.new(@view.class, @options).find
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/partial_finder.rb ADDED

@@ -0,0 +1,73 @@
+require 'hanami/view/rendering/template_finder'
+module Hanami
+  module View
+    module Rendering
+      # Find a partial for the current view context.
+      # It's used when a template wants to render a partial.
+      #
+      # @see Hanami::View::Rendering::Partial
+      # @see Hanami::View::Rendering::TemplateFinder
+      #
+      # @api private
+      # @since 0.1.0
+      class PartialFinder < TemplateFinder
+        # Template file name prefix.
+        # By convention a partial file name starts with this prefix.
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @example
+        #   "_sidebar.html.erb"
+        PREFIX = '_'.freeze
+        # Find a template for a partial. Initially it will look for the
+        # partial template under the directory of the parent directory
+        # view template, if not found it will search recursivly from
+        # the view root.
+        #
+        # @return [Hanami::View::Template] the requested template
+        #
+        # @see Hanami::View::Rendering::TemplateFinder#find
+        #
+        # @since 0.4.3
+        # @api private
+        def find
+          if path = partial_template_under_view_path
+            View::Template.new(path, @view.configuration.default_encoding)
+          else
+            super
+          end
+        end
+        protected
+        # @since 0.4.3
+        # @api private
+        def partial_template_under_view_path
+          _find(view_template_dir).first
+        end
+        # @since 0.4.3
+        # @api private
+        def view_template_dir
+          *all, _ = @view.template.split(separator)
+          all.join(separator)
+        end
+        def template_name
+          *all, last = partial_name.split(separator)
+          all.push( last.prepend(prefix) ).join(separator)
+        end
+        def partial_name
+          @options[:partial]
+        end
+        def prefix
+          PREFIX
+        end
+      end
+    end
+  end
+end