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

hanami-view 0.0.0 → 0.6.0

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