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/inheritable.rb ADDED

@@ -0,0 +1,54 @@
+module Hanami
+  module View
+    # Inheriting mechanisms
+    #
+    # @since 0.1.0
+    module Inheritable
+      # Register a view subclass
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/view'
+      #
+      #   class IndexView
+      #     include Hanami::View
+      #   end
+      #
+      #   class JsonIndexView < IndexView
+      #   end
+      def inherited(base)
+        subclasses.add base
+      end
+      # Set of registered subclasses
+      #
+      # @api private
+      # @since 0.1.0
+      def subclasses
+        @subclasses ||= Set.new
+      end
+      protected
+      # Loading mechanism hook.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::View.load!
+      def load!
+        subclasses.freeze
+        views.freeze
+      end
+      # Registered views
+      #
+      # @api private
+      # @since 0.1.0
+      def views
+        @views ||= [ self ] + subclasses.to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,265 @@
+require 'hanami/view/rendering/registry'
+require 'hanami/view/rendering/scope'
+module Hanami
+  module View
+    # Rendering methods
+    #
+    # @since 0.1.0
+    #
+    # @see Hanami::View::Rendering::InstanceMethods
+    module Rendering
+      def self.extended(base)
+        base.class_eval do
+          include InstanceMethods
+        end
+      end
+      module InstanceMethods
+        # Initialize a view
+        #
+        # @param template [Hanami::View::Template] the template to render
+        # @param locals [Hash] a set of objects available during the rendering
+        #   process.
+        #
+        # @since 0.1.0
+        #
+        # @see Hanami::View::Template
+        #
+        # @example
+        #   require 'hanami/view'
+        #
+        #   class IndexView
+        #     include Hanami::View
+        #   end
+        #
+        #   template = Hanami::View::Template.new('index.html.erb')
+        #   view     = IndexView.new(template, {article: article})
+        def initialize(template, locals)
+          @template = template
+          @locals   = locals
+          @scope    = Scope.new(self, @locals)
+        end
+        # Render the template by bounding the local scope.
+        # If it uses a layout, it renders the template first and then the
+        # control passes to the layout.
+        #
+        # Override this method for custom rendering policies.
+        # For instance, when a serializer is used and there isn't the need of
+        # a template.
+        #
+        # @return [String] the output of the rendering process
+        #
+        # @raise [Hanami::View::MissingTemplateError] if the template is nil
+        #
+        # @since 0.1.0
+        #
+        # @see Hanami::View::Layout
+        #
+        # @example with template
+        #   require 'hanami/view'
+        #
+        #   class IndexView
+        #     include Hanami::View
+        #   end
+        #
+        #   template = Hanami::View::Template.new('index.html.erb')
+        #   view     = IndexView.new(template, {article: article})
+        #
+        #   view.render # => <h1>Introducing Hanami::view</h1> ...
+        #
+        # @example with template and layout
+        #   require 'hanami/view'
+        #
+        #   class ApplicationLayout
+        #     include Hanami::View::Layout
+        #   end
+        #
+        #   class IndexView
+        #     include Hanami::View
+        #     layout :application
+        #   end
+        #
+        #   template = Hanami::View::Template.new('index.html.erb')
+        #   view     = IndexView.new(template, {article: article})
+        #
+        #   view.render # => <html> ... <h1>Introducing Hanami::view</h1> ...
+        #
+        # @example with custom rendering
+        #   require 'hanami/view'
+        #
+        #   class IndexView
+        #     include Hanami::View
+        #
+        #     def render
+        #       ArticleSerializer.new(article).render
+        #     end
+        #   end
+        #
+        #   view = IndexView.new(nil, {article: article})
+        #
+        #   view.render # => {title: ...}
+        def render
+          layout.render
+        end
+        protected
+        # The output of the template rendering process.
+        #
+        # @return [String] the rendering output
+        #
+        # @raise [Hanami::View::MissingTemplateError] if the template is nil
+        #
+        # @api private
+        # @since 0.1.0
+        def rendered
+          template.render @scope
+        end
+        # The layout.
+        #
+        # @return [Class, Hanami::View::Rendering::NullLayout]
+        #
+        # @see Hanami::View::Layout
+        # @see Hanami::View.layout
+        # @see Hanami::View::Dsl#layout
+        #
+        # @api private
+        # @since 0.1.0
+        def layout
+          @layout ||= self.class.layout.new(@scope, rendered)
+        end
+        # The template.
+        #
+        # @return [Hanami::View::Template] the template
+        #
+        # @raise [Hanami::View::MissingTemplateError] if the template is nil
+        #
+        # @api private
+        # @since 0.1.0
+        def template
+          @template or raise MissingTemplateError.new(self.class.template, @scope.format)
+        end
+        # A set of objects available during the rendering process.
+        #
+        # @return [Hash]
+        #
+        # @see Hanami::View#initialize
+        #
+        # @api private
+        # @since 0.1.0
+        def locals
+          @locals
+        end
+        # Delegates missing methods to the scope.
+        #
+        # @see Hanami::View::Rendering::Scope
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @example
+        #   require 'hanami/view'
+        #
+        #   class IndexView
+        #     include Hanami::View
+        #   end
+        #
+        #   template = Hanami::View::Template.new('index.html.erb')
+        #   view     = IndexView.new(template, {article: article})
+        #
+        #   view.article # => #<Article:0x007fb0bbd3b6e8>
+        def method_missing(m)
+          @scope.__send__ m
+        end
+      end
+      # Render the given context and locals with the appropriate template.
+      # If there are registered subclasses, it choose the right class, according
+      #   to the requested format.
+      #
+      # @param context [Hash] the context for the rendering process
+      # @option context [Symbol] :format the requested format
+      #
+      # @return [String] the output of the rendering process
+      #
+      # @raise [Hanami::View::MissingTemplateError] if it can't find a template
+      #   for the given context
+      #
+      # @raise [Hanami::View::MissingFormatError] if the given context doesn't
+      #   have the :format key
+      #
+      # @since 0.1.0
+      #
+      # @see Hanami::View#initialize
+      # @see Hanami::View#render
+      #
+      # @example
+      #   require 'hanami/view'
+      #
+      #   article = OpenStruct.new(title: 'Hello')
+      #
+      #   module Articles
+      #     class Show
+      #       include Hanami::View
+      #
+      #       def title
+      #         @title ||= article.title.upcase
+      #       end
+      #     end
+      #
+      #     class JsonShow < Show
+      #       format :json
+      #
+      #       def title
+      #         super.downcase
+      #       end
+      #     end
+      #   end
+      #
+      #   Hanami::View.root = '/path/to/templates'
+      #   Hanami::View.load!
+      #
+      #   Articles::Show.render(format: :html,  article: article)
+      #     # => renders `articles/show.html.erb`
+      #
+      #   Articles::Show.render(format: :json, article: article)
+      #     # => renders `articles/show.json.erb`
+      #
+      #   Articles::Show.render(format: :xml, article: article)
+      #     # => raises Hanami::View::MissingTemplateError
+      def render(context)
+        registry.resolve(context).render
+      end
+      protected
+      # Loading mechanism hook.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::View.load!
+      def load!
+        super
+        registry.freeze
+      end
+      private
+      # The registry that holds all the registered subclasses.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::View::Rendering::Registry
+      def registry
+        @registry ||= Registry.new(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+require 'hanami/utils/string'
+require 'hanami/utils/class'
+require 'hanami/view/rendering/null_layout'
+module Hanami
+  module View
+    module Rendering
+      # Defines the logic to find a layout
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::Layout
+      class LayoutFinder
+        # Layout class name suffix
+        #
+        # @api private
+        # @since 0.1.0
+        SUFFIX = 'Layout'.freeze
+        # Find a layout from the given name.
+        #
+        # @param layout [Symbol,String,NilClass] layout name or nil if you want
+        #   to fallback to the framework defaults (see `Hanami::View.layout`).
+        #
+        # @param namespace [Class,Module] a Ruby namespace where to lookup
+        #
+        # @return [Hanami::Layout] the layout for the given name or
+        #   `Hanami::View.layout`
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @example With given name
+        #   require 'hanami/view'
+        #
+        #   Hanami::View::Rendering::LayoutFinder.find(:article) # =>
+        #     ArticleLayout
+        #
+        # @example With a class
+        #   require 'hanami/view'
+        #
+        #   Hanami::View::Rendering::LayoutFinder.find(ArticleLayout) # =>
+        #     ArticleLayout
+        #
+        # @example With namespace
+        #   require 'hanami/view'
+        #
+        #   Hanami::View::Rendering::LayoutFinder.find(:application, CardDeck) # =>
+        #     CardDeck::ApplicationLayout
+        #
+        # @example With nil
+        #   require 'hanami/view'
+        #
+        #   Hanami::View::Rendering::LayoutFinder.find(nil) # =>
+        #     Hanami::View::Rendering::NullLayout
+        #
+        # @example With unknown layout
+        #   require 'hanami/view'
+        #
+        #   Hanami::View::Rendering::LayoutFinder.find(:unknown) # =>
+        #     Hanami::View::Rendering::NullLayout
+        #
+        def self.find(layout, namespace = Object)
+          case layout
+          when Symbol, String
+            # TODO Move this low level logic into a Hanami::Utils solution
+            class_name = "#{ Utils::String.new(layout).classify }#{ SUFFIX }"
+            namespace  = Utils::Class.load_from_pattern!(namespace)
+            namespace.const_get(class_name)
+          when Class
+            layout
+          end || NullLayout
+        end
+        # Initialize the finder
+        #
+        # @param view [Class, #layout]
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(view)
+          @view = view
+        end
+        # Find the layout for the view
+        #
+        # @return [Hanami::Layout] the layout associated to the view
+        #
+        # @see Hanami::View::Rendering::LayoutFinder.find
+        # @see Hanami::View::Rendering::LayoutFinder#initialize
+        #
+        # @api private
+        # @since 0.1.0
+        #
+        # @example With layout
+        #   require 'hanami/view'
+        #
+        #   module Articles
+        #     class Show
+        #       include Hanami::View
+        #       layout :article
+        #     end
+        #   end
+        #
+        #   Hanami::View::Rendering::LayoutFinder.new(Articles::Show) # =>
+        #     ArticleLayout
+        #
+        # @example Without layout
+        #   require 'hanami/view'
+        #
+        #   module Dashboard
+        #     class Index
+        #       include Hanami::View
+        #     end
+        #   end
+        #
+        #   Hanami::View.layout # => :application
+        #
+        #   Hanami::View::Rendering::LayoutFinder.new(Dashboard::Index) # =>
+        #     ApplicationLayout
+        def find
+          self.class.find(@view.layout)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'hanami/view/rendering/null_template'
+require 'hanami/view/rendering/templates_finder'
+module Hanami
+  module View
+    module Rendering
+      # Holds the references of all the registered layouts.
+      # As now the registry is unique at the level of the framework.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::Layout::ClassMethods#registry
+      class LayoutRegistry
+        # Initialize the registry
+        #
+        # @param view [Class] the view
+        #
+        # @api private
+        # @since 0.1.0
+        def initialize(view)
+          @registry = {}
+          @view = view
+          prepare!
+        end
+        # Returns the layout for the given context.
+        #
+        # @param context [Hash] the rendering context
+        # @option context [Symbol] :format the requested format
+        #
+        # @return [Hanami::Layout, Hanami::View::Rendering::NullTemplate]
+        #   the layout associated with the given context or a `NullTemplate` if
+        #   it can't be found.
+        #
+        # @raise [Hanami::View::MissingFormatError] if the given context doesn't
+        #   have the :format key
+        #
+        # @api private
+        # @since 0.1.0
+        def resolve(context)
+          @registry.fetch(format(context)) { NullTemplate.new }
+        end
+        protected
+        def prepare!
+          templates.each do |template|
+            @registry.merge! template.format => template
+          end
+          @registry.any? or raise MissingTemplateLayoutError.new(@view)
+        end
+        def templates
+          TemplatesFinder.new(@view).find
+        end
+        def format(context)
+          context.fetch(:format) { raise MissingFormatError }
+        end
+      end
+    end
+  end
+end