hanami-view 0.0.0 → 0.6.0

data/hanami-view.gemspec

@@ -4,20 +4,25 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'hanami/view/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "hanami-view"
+  spec.name          = 'hanami-view'
   spec.version       = Hanami::View::VERSION
-  spec.authors       = ["Luca Guidi"]
-  spec.email         = ["me@lucaguidi.com"]
+  spec.authors       = ['Luca Guidi', 'Trung Lê', 'Alfonso Uceda']
+  spec.email         = ['me@lucaguidi.com', 'trung.le@ruby-journal.com', 'uceda73@gmail.com']
+  spec.description   = %q{View layer for Hanami}
+  spec.summary       = %q{View layer for Hanami, with a separation between views and templates}
+  spec.homepage      = 'http://hanamirb.org'
+  spec.license       = 'MIT'
 
-  spec.summary       = %q{The web, with simplicity}
-  spec.description   = %q{Hanami is a web framework for Ruby}
-  spec.homepage      = "http://hanamirb.org"
+  spec.files         = `git ls-files -- lib/* CHANGELOG.md LICENSE.md README.md hanami-view.gemspec`.split($/)
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(test)/})
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.0.0'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency 'tilt',        '~> 2.0', '>= 2.0.1'
+  spec.add_runtime_dependency 'hanami-utils', '~> 0.7'
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler',  '~> 1.5'
+  spec.add_development_dependency 'minitest', '~> 5'
+  spec.add_development_dependency 'rake',     '~> 10'
 end

data/lib/hanami-view.rb

@@ -0,0 +1 @@
+require 'hanami/view'

data/lib/hanami/layout.rb

@@ -0,0 +1,142 @@
+require 'hanami/utils/class_attribute'
+require 'hanami/view/rendering/layout_registry'
+require 'hanami/view/rendering/layout_scope'
+require 'hanami/view/rendering/null_layout'
+
+module Hanami
+  # Layout
+  #
+  # @since 0.1.0
+  #
+  # @see Hanami::Layout::ClassMethods
+  module Layout
+    # Register a layout
+    #
+    # @api private
+    # @since 0.1.0
+    #
+    # @example
+    #   require 'hanami/view'
+    #
+    #   class ApplicationLayout
+    #     include Hanami::Layout
+    #   end
+    def self.included(base)
+      conf = Hanami::View::Configuration.for(base)
+      conf.add_layout(base)
+
+      base.class_eval do
+        extend Hanami::View::Dsl.dup
+        extend ClassMethods
+
+        include Utils::ClassAttribute
+        class_attribute :configuration
+
+        self.configuration = conf.duplicate
+      end
+
+      conf.copy!(base)
+    end
+
+    # Class level API
+    #
+    # @since 0.1.0
+    module ClassMethods
+      # Template name suffix
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::Layout::ClassMethods#suffix
+      # @see Hanami::Layout::ClassMethods#template
+      SUFFIX = '_layout'.freeze
+
+      # A registry that holds all the registered layouts.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::View::Rendering::LayoutRegistry
+      def registry
+        @registry ||= View::Rendering::LayoutRegistry.new(self)
+      end
+
+      # Template name
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::Layout::ClassMethods#SUFFIX
+      # @see Hanami::Layout::ClassMethods#suffix
+      #
+      # @example
+      #   # Given a template 'templates/application.html.erb'
+      #
+      #   class ApplicationLayout
+      #     include Hanami::Layout
+      #   end
+      #
+      # ApplicationLayout.template # => 'application'
+      def template
+        super.sub(suffix, '')
+      end
+
+      # Template name suffix
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::Layout::ClassMethods#SUFFIX
+      # @see Hanami::Layout::ClassMethods#template
+      def suffix
+        SUFFIX
+      end
+
+      protected
+      # Loading mechanism hook.
+      #
+      # @api private
+      # @since 0.1.0
+      #
+      # @see Hanami::View.load!
+      def load!
+        registry.freeze
+        configuration.freeze
+      end
+    end
+
+    # 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::View::Rendering#render
+    def initialize(scope, rendered)
+      @scope, @rendered = View::Rendering::LayoutScope.new(self, scope), rendered
+    end
+
+    # Render the layout
+    #
+    # @return [String] the output of the rendering process
+    #
+    # @api private
+    # @since 0.1.0
+    #
+    # @see Hanami::View::Rendering#render
+    def render
+      template.render(@scope, &Proc.new{@rendered})
+    end
+
+    protected
+    # The template for the current format
+    #
+    # @api private
+    # @since 0.1.0
+    def template
+      self.class.registry.resolve({format: @scope.format})
+    end
+  end
+end

data/lib/hanami/presenter.rb

@@ -0,0 +1,126 @@
+require 'hanami/view/escape'
+
+module Hanami
+  # Presenter pattern implementation
+  #
+  # It delegates to the wrapped object the missing method invocations.
+  #
+  # The output of concrete and delegated methods is escaped as XSS prevention.
+  #
+  # @since 0.1.0
+  #
+  # @example Basic usage
+  #   require 'hanami/view'
+  #
+  #   class Map
+  #     attr_reader :locations
+  #
+  #     def initialize(locations)
+  #       @locations = locations
+  #     end
+  #
+  #     def location_names
+  #       @locations.join(', ')
+  #     end
+  #   end
+  #
+  #   class MapPresenter
+  #     include Hanami::Presenter
+  #
+  #     def count
+  #       locations.count
+  #     end
+  #
+  #     def location_names
+  #       super.upcase
+  #     end
+  #
+  #     def inspect_object
+  #       @object.inspect
+  #     end
+  #   end
+  #
+  #   map = Map.new(['Rome', 'Boston'])
+  #   presenter = MapPresenter.new(map)
+  #
+  #   # access a map method
+  #   puts presenter.locations # => ['Rome', 'Boston']
+  #
+  #   # access presenter concrete methods
+  #   puts presenter.count # => 1
+  #
+  #   # uses super to access original object implementation
+  #   puts presenter.location_names # => 'ROME, BOSTON'
+  #
+  #   # it has private access to the original object
+  #   puts presenter.inspect_object # => #<Map:0x007fdeada0b2f0 @locations=["Rome", "Boston"]>
+  #
+  # @example Escape
+  #   require 'hanami/view'
+  #
+  #   User = Struct.new(:first_name, :last_name)
+  #
+  #   class UserPresenter
+  #     include Hanami::Presenter
+  #
+  #     def full_name
+  #       [first_name, last_name].join(' ')
+  #     end
+  #
+  #     def raw_first_name
+  #       _raw first_name
+  #     end
+  #   end
+  #
+  #   first_name = '<script>alert('xss')</script>'
+  #
+  #   user = User.new(first_name, nil)
+  #   presenter = UserPresenter.new(user)
+  #
+  #   presenter.full_name
+  #     # => "&lt;script&gt;alert(&apos;xss&apos;)&lt;&#x2F;script&gt;"
+  #
+  #   presenter.raw_full_name
+  #      # => "<script>alert('xss')</script>"
+  module Presenter
+    # Inject escape logic into the given class.
+    #
+    # @since 0.4.0
+    # @api private
+    #
+    # @see Hanami::View::Escape
+    def self.included(base)
+      base.extend ::Hanami::View::Escape
+    end
+
+    # Initialize the presenter
+    #
+    # @param object [Object] the object to present
+    #
+    # @since 0.1.0
+    def initialize(object)
+      @object = object
+    end
+
+    protected
+    # Override Ruby's method_missing
+    #
+    # @api private
+    # @since 0.1.0
+    def method_missing(m, *args, &blk)
+      if @object.respond_to?(m)
+        ::Hanami::View::Escape.html(@object.__send__(m, *args, &blk))
+      else
+        super
+      end
+    end
+
+    # Override Ruby's respond_to_missing? in order to support proper delegation
+    #
+    # @api private
+    # @since 0.3.0
+    def respond_to_missing?(m, include_private = false)
+      @object.respond_to?(m, include_private)
+    end
+  end
+end

data/lib/hanami/view.rb

@@ -1,7 +1,264 @@
-require "hanami/view/version"
+require 'set'
+require 'pathname'
+require 'hanami/utils/class_attribute'
+require 'hanami/view/version'
+require 'hanami/view/configuration'
+require 'hanami/view/inheritable'
+require 'hanami/view/rendering'
+require 'hanami/view/escape'
+require 'hanami/view/dsl'
+require 'hanami/view/errors'
+require 'hanami/layout'
+require 'hanami/presenter'
 
 module Hanami
+  # View
+  #
+  # @since 0.1.0
   module View
-    # Your code goes here...
+    include Utils::ClassAttribute
+    # Framework configuration
+    #
+    # @since 0.2.0
+    # @api private
+    class_attribute :configuration
+    self.configuration = Configuration.new
+
+    # Configure the framework.
+    # It yields the given block in the context of the configuration
+    #
+    # @param blk [Proc] the configuration block
+    #
+    # @since 0.2.0
+    #
+    # @see Hanami::View::Configuration
+    #
+    # @example
+    #   require 'hanami/view'
+    #
+    #   Hanami::View.configure do
+    #     root '/path/to/root'
+    #   end
+    def self.configure(&blk)
+      configuration.instance_eval(&blk)
+    end
+
+    # Duplicate Hanami::View in order to create a new separated instance
+    # of the framework.
+    #
+    # The new instance of the framework will be completely decoupled from the
+    # original. It will inherit the configuration, but all the changes that
+    # happen after the duplication, won't be reflected on the other copies.
+    #
+    # @return [Module] a copy of Hanami::View
+    #
+    # @since 0.2.0
+    # @api private
+    #
+    # @example Basic usage
+    #   require 'hanami/view'
+    #
+    #   module MyApp
+    #     View = Hanami::View.dupe
+    #   end
+    #
+    #   MyApp::View == Hanami::View # => false
+    #
+    #   MyApp::View.configuration ==
+    #     Hanami::View.configuration # => false
+    #
+    # @example Inheriting configuration
+    #   require 'hanami/view'
+    #
+    #   Hanami::View.configure do
+    #     root '/path/to/root'
+    #   end
+    #
+    #   module MyApp
+    #     View = Hanami::View.dupe
+    #   end
+    #
+    #   module MyApi
+    #     View = Hanami::View.dupe
+    #     View.configure do
+    #       root '/another/root'
+    #     end
+    #   end
+    #
+    #   Hanami::View.configuration.root # => #<Pathname:/path/to/root>
+    #   MyApp::View.configuration.root # => #<Pathname:/path/to/root>
+    #   MyApi::View.configuration.root # => #<Pathname:/another/root>
+    def self.dupe
+      dup.tap do |duplicated|
+        duplicated.configuration = configuration.duplicate
+      end
+    end
+
+    # Duplicate the framework and generate modules for the target application
+    #
+    # @param mod [Module] the Ruby namespace of the application
+    # @param views [String] the optional namespace where the application's
+    #   views will live
+    # @param blk [Proc] an optional block to configure the framework
+    #
+    # @return [Module] a copy of Hanami::View
+    #
+    # @since 0.2.0
+    #
+    # @see Hanami::View#dupe
+    # @see Hanami::View::Configuration
+    # @see Hanami::View::Configuration#namespace
+    #
+    # @example Basic usage
+    #   require 'hanami/view'
+    #
+    #   module MyApp
+    #     View = Hanami::View.duplicate(self)
+    #   end
+    #
+    #   # It will:
+    #   #
+    #   # 1. Generate MyApp::View
+    #   # 2. Generate MyApp::Layout
+    #   # 3. Generate MyApp::Presenter
+    #   # 4. Generate MyApp::Views
+    #   # 5. Configure MyApp::Views as the default namespace for views
+    #
+    #  module MyApp::Views::Dashboard
+    #    class Index
+    #      include MyApp::View
+    #    end
+    #  end
+    #
+    # @example Compare code
+    #   require 'hanami/view'
+    #
+    #   module MyApp
+    #     View = Hanami::View.duplicate(self) do
+    #       # ...
+    #     end
+    #   end
+    #
+    #   # it's equivalent to:
+    #
+    #   module MyApp
+    #     View   = Hanami::View.dupe
+    #     Layout = Hanami::Layout.dup
+    #
+    #     module Views
+    #     end
+    #
+    #     View.configure do
+    #       namespace 'MyApp::Views'
+    #     end
+    #
+    #     View.configure do
+    #       # ...
+    #     end
+    #   end
+    #
+    # @example Custom views module
+    #   require 'hanami/view
+    #
+    #   module MyApp
+    #     View = Hanami::View.duplicate(self, 'Vs')
+    #   end
+    #
+    #   defined?(MyApp::Views) # => nil
+    #   defined?(MyApp::Vs)    # => "constant"
+    #
+    #   # Developers can namespace views under Vs
+    #   module MyApp::Vs::Dashboard
+    #     # ...
+    #   end
+    #
+    # @example Nil views module
+    #   require 'hanami/view'
+    #
+    #   module MyApp
+    #     View = Hanami::View.duplicate(self, nil)
+    #   end
+    #
+    #   defined?(MyApp::Views) # => nil
+    #
+    #   # Developers can namespace views under MyApp
+    #   module MyApp
+    #     # ...
+    #   end
+    #
+    # @example Block usage
+    #   require 'hanami/view'
+    #
+    #   module MyApp
+    #     View = Hanami::View.duplicate(self) do
+    #       root '/path/to/root'
+    #     end
+    #   end
+    #
+    #   Hanami::View.configuration.root # => #<Pathname:.>
+    #   MyApp::View.configuration.root # => #<Pathname:/path/to/root>
+    def self.duplicate(mod, views = 'Views', &blk)
+      dupe.tap do |duplicated|
+        mod.module_eval %{ module #{ views }; end } if views
+        mod.module_eval %{
+          Layout = Hanami::Layout.dup
+          Presenter = Hanami::Presenter.dup
+        }
+
+        duplicated.configure do
+          namespace [mod, views].compact.join '::'
+        end
+
+        duplicated.configure(&blk) if block_given?
+      end
+    end
+
+    # Override Ruby's hook for modules.
+    # It includes basic Hanami::View modules to the given Class.
+    # It sets a copy of the framework configuration
+    #
+    # @param base [Class] the target view
+    #
+    # @since 0.1.0
+    # @api private
+    #
+    # @see http://www.ruby-doc.org/core-2.1.2/Module.html#method-i-included
+    #
+    # @see Hanami::View::Dsl
+    # @see Hanami::View::Inheritable
+    # @see Hanami::View::Rendering
+    #
+    # @example
+    #   require 'hanami/view'
+    #
+    #   class IndexView
+    #     include Hanami::View
+    #   end
+    def self.included(base)
+      conf = self.configuration
+      conf.add_view(base)
+
+      base.class_eval do
+        extend Inheritable
+        extend Dsl
+        extend Rendering
+        extend Escape
+
+        include Utils::ClassAttribute
+        class_attribute :configuration
+
+        self.configuration = conf.duplicate
+      end
+
+      conf.copy!(base)
+    end
+
+    # Load the framework
+    #
+    # @since 0.1.0
+    # @api private
+    def self.load!
+      configuration.load!
+    end
   end
 end