hanami-view 0.0.0 → 0.6.0

data/lib/hanami/view/rendering/registry.rb

@@ -0,0 +1,128 @@
+require 'hanami/view/rendering/layout_registry'
+require 'hanami/view/rendering/view_finder'
+
+module Hanami
+  module View
+    module Rendering
+      # Holds all the references of all the registered subclasses of a view.
+      # We have one registry for each superclass view.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::View::Rendering::LayoutRegistry
+      # @see Hanami::View::Rendering#registry
+      #
+      # @example
+      #   require 'hanami/view'
+      #
+      #   module Articles
+      #     class Index
+      #       include Hanami::View
+      #     end
+      #
+      #     class Show
+      #       include Hanami::View
+      #     end
+      #
+      #     class JsonShow < Show
+      #       format :json
+      #     end
+      #
+      #     class XmlShow < Show
+      #       format :xml
+      #
+      #       def render
+      #         ArticleSerializer.new(article).to_xml
+      #       end
+      #     end
+      #   end
+      #
+      #   # We have the following templates:
+      #   #
+      #   #  * articles/index.html.erb
+      #   #  * articles/index.atom.erb
+      #   #  * articles/show.html.erb
+      #   #  * articles/show.json.erb
+      #
+      #   # One registry per superclass view
+      #   Articles::Index.send(:registry).object_id     # => 70135342862240
+      #
+      #   Articles::Show.send(:registry).object_id      # => 70135342110540
+      #   Articles::XmlShow.send(:registry).object_id   # => 70135342110540
+      #   Articles::JsonShow.send(:registry).object_id  # => 70135342110540
+      #
+      #
+      #
+      #   # It holds the references for all the templates and the views
+      #   Articles::Index.send(:registry).inspect
+      #     # => { :all  => [Articles::Index, nil],
+      #     #      :atom => [Articles::Index, #<Hanami::View::Template ... @file="/path/to/templates/articles/index.atom.erb"],
+      #     #      :html => [Articles::Index, #<Hanami::View::Template ... @file="/path/to/templates/articles/index.html.erb"] }
+      #
+      #   Articles::Show.send(:registry).inspect
+      #     # => { :all  => [Articles::Show, nil],
+      #     #      :html => [Articles::Show,     #<Hanami::View::Template ... @file="/path/to/templates/articles/show.html.erb"],
+      #     #      :json => [Articles::JsonShow, #<Hanami::View::Template ... @file="/path/to/templates/articles/show.json.erb"],
+      #     #      :xml  => [Articles::XmlShow, nil] }
+      class Registry < LayoutRegistry
+        # Default format for views without an explicit format.
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::View::Dsl#format
+        DEFAULT_FORMAT = :all
+
+        # Returns the view for the given context.
+        #
+        # @param context [Hash] the rendering context
+        # @option context [Symbol] :format the requested format
+        #
+        # @return [Hanami::View] the view associated with the given context
+        #
+        # @raise [Hanami::View::MissingFormatError] if the given context doesn't
+        #   have the :format key
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::View::Rendering#render
+        def resolve(context)
+          view, template = @registry.fetch(format(context)) { @registry[DEFAULT_FORMAT] }
+          view.new(template, context)
+        end
+
+        private
+        def prepare!
+          prepare_views!
+          prepare_templates!
+        end
+
+        def prepare_views!
+          views.each do |view|
+            @registry.merge! view.format || DEFAULT_FORMAT => [ view, template_for(view) ]
+          end
+        end
+
+        def prepare_templates!
+          templates.each do |template|
+            @registry.merge! template.format => [ view_for(template), template ]
+          end
+        end
+
+        def views
+          @view.subclasses + [ @view ]
+        end
+
+        def view_for(template)
+          ViewFinder.new(@view).find(template)
+        end
+
+        def template_for(view)
+          templates.find {|template| template.format == view.format }
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/scope.rb

@@ -0,0 +1,88 @@
+require 'hanami/utils/escape'
+require 'hanami/view/rendering/layout_scope'
+require 'hanami/view/rendering/template'
+require 'hanami/view/rendering/partial'
+
+module Hanami
+  module View
+    module Rendering
+      # Rendering scope
+      #
+      # @since 0.1.0
+      #
+      # @see Hanami::View::Rendering::LayoutScope
+      class Scope < LayoutScope
+        # Initialize the scope
+        #
+        # @param view [Class] the view
+        # @param locals [Hash] a set of objects available during the rendering
+        # @option locals [Symbol] :format the requested format
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(view, locals = {})
+          @view, @locals, @layout = view, locals, layout
+        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 << " @view=\"#{@view}\"" if @view
+          base << " @locals=\"#{@locals}\"" if @locals
+          base << ">"
+        end
+
+        # Returns the requested format.
+        #
+        # @return [Symbol] the requested format (eg. :html, :json, :xml, etc..)
+        #
+        # @since 0.1.0
+        def format
+          locals[:format]
+        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)
+          @view.respond_to?(m) ||
+            @locals.key?(m)
+        end
+
+        protected
+        def method_missing(m, *args, &block)
+          ::Hanami::View::Escape.html(
+            if @view.respond_to?(m)
+              @view.__send__ m, *args, &block
+            elsif @locals.key?(m)
+              @locals[m]
+            else
+              super
+            end
+          )
+        end
+
+        private
+
+        # @since 0.4.2
+        # @api private
+        def layout
+          if @view.class.respond_to?(:layout)
+            @view.class.layout.new(self, "")
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/template.rb

@@ -0,0 +1,67 @@
+require 'hanami/view/rendering/template_finder'
+
+module Hanami
+  module View
+    module Rendering
+      # Rendering template
+      #
+      # It's used when a template wants to render another template.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::View::Rendering::LayoutScope#render
+      #
+      # @example
+      #   # We have an application template (templates/application.html.erb)
+      #   # that uses the following line:
+      #
+      #   <%= render template: 'articles/show' %>
+      class Template
+        # Initialize a template
+        #
+        # @param view [Hanami::View] the current view
+        # @param options [Hash] the rendering informations
+        # @option options [Symbol] :format the current format
+        # @option options [Hash] :locals the set of objects available within
+        #   the rendering context
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(view, options)
+          @view, @options = view, options
+        end
+
+        # Render the template.
+        #
+        # @return [String] the output of the rendering process.
+        #
+        # @raise [Hanami::View::MissingTemplateError] if template can't be found
+        #
+        # @api private
+        # @since 0.1.0
+        def render
+          (template or raise_missing_template_error).render(scope)
+        end
+
+        protected
+        def template
+          TemplateFinder.new(@view.class, @options).find
+        end
+
+        def scope
+          Scope.new(@view, @options[:locals])
+        end
+
+        # @since 0.5.0
+        # @api private
+        def raise_missing_template_error
+          raise MissingTemplateError.new(
+            @options.fetch(:template) { @options.fetch(:partial, nil) },
+            @options[:format]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/template_finder.rb

@@ -0,0 +1,53 @@
+require 'hanami/view/rendering/templates_finder'
+
+module Hanami
+  module View
+    module Rendering
+      # Find a template for the current view context.
+      # It's used when a template wants to render another template.
+      #
+      # @see Hanami::View::Rendering::Template
+      # @see Hanami::View::Rendering::TemplatesFinder
+      #
+      # @api private
+      # @since 0.1.0
+      class TemplateFinder < TemplatesFinder
+        # Initialize a finder
+        #
+        # @param view [Class] a view
+        # @param options [Hash] the informations about the context
+        # @option options [String] :template the template file name
+        # @option options [Symbol] :format the requested format
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(view, options)
+          super(view)
+          @options = options
+        end
+
+        # Find a template for the current view context
+        #
+        # @return [Hanami::View::Template] the requested template
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::View::Rendering::TemplatesFinder#find
+        # @see Hanami::View::Rendering::Template#render
+        def find
+          super.first
+        end
+
+        protected
+        def template_name
+          @options[:template]
+        end
+
+        def format
+          @options[:format]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/template_name.rb

@@ -0,0 +1,37 @@
+require 'hanami/utils/string'
+
+module Hanami
+  module View
+    module Rendering
+      # @since 0.2.0
+      class TemplateName
+        NAMESPACE_SEPARATOR = '::'.freeze
+
+        def initialize(name, namespace)
+          @name = name
+          compile!(namespace)
+        end
+
+        def to_s
+          @name
+        end
+
+        private
+        def compile!(namespace)
+          tokens(namespace) {|token| replace!(token) }
+          @name = Utils::String.new(@name).underscore
+        end
+
+        def tokens(namespace)
+          namespace.to_s.split(NAMESPACE_SEPARATOR).each do |token|
+            yield token
+          end
+        end
+
+        def replace!(token)
+          @name.gsub!(%r{\A#{ token }#{ NAMESPACE_SEPARATOR }}, '')
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/rendering/templates_finder.rb

@@ -0,0 +1,129 @@
+require 'hanami/view/template'
+
+module Hanami
+  module View
+    module Rendering
+      # Find templates for a view
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see View::Template
+      class TemplatesFinder
+        # Default format
+        #
+        # @api private
+        # @since 0.1.0
+        FORMAT    = '*'.freeze
+
+        # Default template engines
+        #
+        # @api private
+        # @since 0.1.0
+        ENGINES   = '*'.freeze
+
+        # Recursive pattern
+        #
+        # @api private
+        # @since 0.2.0
+        RECURSIVE = '**'.freeze
+
+        # Initialize a finder
+        #
+        # @param view [Class] the view
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(view)
+          @view = view
+        end
+
+        # Find all the associated templates to the view.
+        # It recursively looks for templates under the root path of the view,
+        # that are matching the template name
+        #
+        # @return [Array<Hanami::View::Template>] the templates
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @see Hanami::View::Dsl#root
+        # @see Hanami::View::Dsl#template
+        #
+        # @example
+        #   require 'hanami/view'
+        #
+        #   module Articles
+        #     class Show
+        #       include Hanami::View
+        #     end
+        #   end
+        #
+        #   Articles::Show.root     # => "/path/to/templates"
+        #   Articles::Show.template # => "articles/show"
+        #
+        #   # This view has a template:
+        #   #
+        #   #   "/path/to/templates/articles/show.html.erb"
+        #
+        #   Hanami::View::Rendering::TemplatesFinder.new(Articles::Show).find
+        #     # => [#<Hanami::View::Template:0x007f8a0a86a970 ... @file="/path/to/templates/articles/show.html.erb">]
+        def find
+          _find.map do |template|
+            View::Template.new(template, @view.configuration.default_encoding)
+          end
+        end
+
+        protected
+
+        # @api private
+        # @since 0.4.3
+        def _find(lookup = search_path)
+          Dir.glob( "#{ [root, lookup, template_name].join(separator) }.#{ format }.#{ engines }" )
+        end
+
+        # @api private
+        # @since 0.1.0
+        def template_name
+          @view.template
+        end
+
+        # @api private
+        # @since 0.1.0
+        def root
+          @view.root
+        end
+
+        # @api private
+        # @since 0.4.3
+        def search_path
+          recursive
+        end
+
+        # @api private
+        # @since 0.2.0
+        def recursive
+          RECURSIVE
+        end
+
+        # @api private
+        # @since 0.1.0
+        def separator
+          ::File::SEPARATOR
+        end
+
+        # @api private
+        # @since 0.1.0
+        def format
+          FORMAT
+        end
+
+        # @api private
+        # @since 0.1.0
+        def engines
+          ENGINES
+        end
+      end
+    end
+  end
+end