strong_presenter 0.0.1 → 0.1.0

data/lib/generators/rails/presenter_generator.rb

@@ -0,0 +1,36 @@
+module Rails
+  module Generators
+   class PresenterGenerator < NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+      check_class_collision suffix: "Presenter"
+
+      class_option :parent, type: :string, desc: "The parent class for the generated presenter"
+
+      def create_presenter_file
+        template 'presenter.rb', File.join('app/presenters', class_path, "#{file_name}_presenter.rb")
+      end
+
+      hook_for :test_framework
+
+      private
+
+      def parent_class_name
+        options.fetch("parent") do
+          begin
+            require 'application_presenter'
+            ApplicationPresenter
+          rescue LoadError
+            "StrongPresenter::Presenter"
+          end
+        end
+      end
+
+      # Rails 3.0.X compatibility, stolen from https://github.com/jnunemaker/mongomapper/pull/385/files#L1R32
+      unless methods.include?(:module_namespacing)
+        def module_namespacing
+          yield if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/generators/rails/templates/presenter.rb

@@ -0,0 +1,19 @@
+<%- module_namespacing do -%>
+  <%- if parent_class_name.present? -%>
+class <%= class_name %>Presenter < <%= parent_class_name %>
+  <%- else -%>
+class <%= class_name %>
+  <%- end -%>
+  delegate_all
+
+  # Define presentation-specific methods here. Helpers are accessed through
+  # `helpers` (aka `h`). You can override attributes, for example:
+  #
+  #   def created_at
+  #     helpers.content_tag :span, class: 'time' do
+  #       object.created_at.strftime("%a %m/%d/%y")
+  #     end
+  #   end
+
+end
+<% end -%>

data/lib/generators/rspec/presenter_generator.rb

@@ -0,0 +1,9 @@
+module Rspec
+  class PresenterGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_spec_file
+      template 'presenter_spec.rb', File.join('spec/presenters', class_path, "#{singular_name}_presenter_spec.rb")
+    end
+  end
+end

data/lib/generators/rspec/templates/presenter_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe <%= class_name %>Presenter do
+end

data/lib/generators/test_unit/presenter_generator.rb

@@ -0,0 +1,9 @@
+module TestUnit
+  class PresenterGenerator < ::Rails::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_test_file
+      template 'presenter_test.rb', File.join('test/presenters', class_path, "#{singular_name}_presenter_test.rb")
+    end
+  end
+end

data/lib/generators/test_unit/templates/presenter_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class <%= class_name %>PresenterTest < StrongPresenter::TestCase
+end

data/lib/strong_presenter/associable.rb

@@ -0,0 +1,78 @@
+module StrongPresenter
+
+  # Methods for defining presenter associations
+  module Associable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      #   Automatically wraps multiple associations.
+      #   @param [Symbol] association
+      #     name of the association to wrap.
+      #   @option options [Class] :with
+      #     the presenter to apply to the association.
+      #   @option options [Symbol] :scope
+      #     a scope to apply when fetching the association.
+      #   @yield
+      #     block executed when association presenter is initialized, in
+      #     the context of the parent presenter instance (instance_exec-ed)
+      #   @yieldparam [Presenter] the association presenter
+      #   @return [void]
+      def presents_association(association, options = {})
+        options.assert_valid_keys(:with, :scope)
+        options[:with] = Associable.object_association_class(object_class, association) unless options.has_key? :with
+        presenter_associations[association] ||= StrongPresenter::PresenterAssociation.new(association, options) do |presenter|
+          presenter.link_permissions self, association
+          yield presenter if block_given?
+        end
+        define_method(association) do
+          self.class.send(:presenter_associations)[association].wrap(self)
+        end
+      end
+
+      # @overload presents_associations(*associations, options = {})
+      #   Automatically wraps multiple associations.
+      #   @param [Symbols*] associations
+      #     names of the associations to wrap.
+      #   @option options [Class] :with
+      #     the presenter to apply to the association.
+      #   @option options [Symbol] :scope
+      #     a scope to apply when fetching the association.
+      #   @yield
+      #     block executed when association presenter is initialized, in
+      #     the context of the parent presenter instance (instance_exec-ed)
+      #   @yieldparam [Presenter] the association presenter
+      #   @return [void]
+      def presents_associations(*associations)
+        options = associations.extract_options!
+        options.assert_valid_keys(:with, :scope)
+        associations.each { |association| presents_association(association, options) {|presenter| yield if block_given?} }
+      end
+
+      private
+      def presenter_associations
+        @presenter_associations ||= {}
+      end
+    end
+
+    protected
+
+    # infer association class if possible
+    def self.object_association_class(object_class, association)
+      if self.descendant_of(object_class, "ActiveRecord::Reflection")
+        association_class = object_class.reflect_on_association(association).klass
+      else
+        return nil
+      end
+      "#{association_class}Presenter".constantize
+    rescue NameError
+      nil
+    end
+
+    def self.descendant_of(object_class, klass)
+      object_class.ancestors.include? klass.constantize
+    rescue NameError
+      false
+    end
+  end
+end
+

data/lib/strong_presenter/collection_presenter.rb

@@ -0,0 +1,90 @@
+module StrongPresenter
+  class CollectionPresenter
+    include Enumerable
+    include StrongPresenter::ViewHelpers
+    include StrongPresenter::Permissible
+    include StrongPresenter::Delegation
+
+    array_methods = Array.instance_methods - Object.instance_methods
+    delegate :==, :as_json, *array_methods, to: :collection
+
+    # @param [Enumerable] object
+    #   collection to present
+    def initialize(object, options = {})
+      options.assert_valid_keys(:with)
+      @object = object
+      @presenter_class = options[:with]
+    end
+
+    def to_s
+      "#<#{self.class.name} of #{presenter_class || "inferred presenters"} for #{object.inspect}>"
+    end
+
+    protected
+    # @return [Class] the presenter class used to present each item, as set by
+    #   {#initialize}.
+    def presenter_class
+      @presenter_class = @presenter_class.nil? ? self.class.send(:presenter_class) : @presenter_class
+    end
+
+    def item_presenter(item)
+      return presenter_class if presenter_class
+      StrongPresenter::Presenter.inferred_presenter(item)
+    end
+
+    # @return the collection being presented.
+    attr_reader :object
+
+    # Wraps the given item.
+    def wrap_item(item)
+      item_presenter(item).new(item).tap do |presenter|
+        presenter.link_permissions self # item's permitted_attributes is linked to collection
+      end
+    end
+
+    # @return [Array] the items being presented
+    def collection
+      @collection ||= object.map{|item| wrap_item(item)}
+    end
+
+    class << self
+      # Sets the presenter used to wrap models in the collection
+      def presents_with presenter
+        @presenter_class = presenter
+        self
+      end
+
+      protected
+      def set_item_presenter_collection
+        collection = self
+        presenter_class.instance_exec do
+          unless nil?
+            if !const_defined? :Collection
+              const_set :Collection, collection
+            elsif self::Collection.name.demodulize == "Collection"
+              remove_const :Collection
+              const_set :Collection, collection
+            end
+          end
+        end
+      rescue NameError => error
+      end
+
+      private
+      def inherited(subclass)
+        subclass.set_item_presenter_collection
+        super
+      end
+
+      def inferred_presenter_class
+        presenter_class = Inferrer.new(name).chomp("Presenter").inferred_class { |name| "#{name.singularize}Presenter" }
+        presenter_class == self ? nil : presenter_class
+      end
+
+      def presenter_class
+        @presenter_class ||= inferred_presenter_class
+      end
+
+    end
+  end
+end

data/lib/strong_presenter/controller_additions.rb

@@ -0,0 +1,50 @@
+module StrongPresenter
+  module ControllerAdditions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # @overload presents(*variables, options = {})
+      #   Defines a helper method to access instance variables wrapped in presenters.
+      #
+      #   @example
+      #     # app/controllers/articles_controller.rb
+      #     class ArticlesController < ApplicationController
+      #       presents :article
+      #       presents :comments, with: ArticleCommentsPresenter, only: :show
+      #       presents :comments, with: CommentsPresenter, only: :index { |presenter| presenter.permit(:author, :text) }
+      #
+      #       def show
+      #         @article = Article.find(params[:id])
+      #       end
+      #     end
+      #
+      #     # app/views/articles/show.html.erb
+      #     <%= article.presented_title %>
+      #
+      #   @param [Symbols*] variables
+      #     names of the instance variables to present (without the `@`).
+      #   @param [Hash] options
+      #   @option options [Presenter, CollectionPresenter] :with (nil)
+      #     presenter class to use. If nil, it is inferred from the instance
+      #     variable.
+      #   @option options [Symbols*] :only (nil)
+      #     apply presenter only on these controller actions.
+      #   @option options [Symbols*] :except (nil)
+      #     don't apply presenter on these controller actions.
+      #   @yield [Presenter] code to execute when presenter is initialized
+      def presents(*variables, &block)
+        options = variables.extract_options!
+        options.assert_valid_keys(:with, :only, :except)
+
+        constructor = StrongPresenter::PresenterHelperConstructor.new(self, block, options)
+
+        variables.each do |variable|
+          constructor.call(variable)
+          helper_method variable
+        end
+      end
+
+    end
+  end
+end
+

data/lib/strong_presenter/delegation.rb

@@ -0,0 +1,18 @@
+module StrongPresenter
+  module Delegation
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # @overload delegate(*methods, options = {})
+      #   Overrides {http://api.rubyonrails.org/classes/Module.html#method-i-delegate Module.delegate}
+      #   to make `:object` the default delegation target.
+      #
+      #   @return [void]
+      def delegate(*methods)
+        options = methods.extract_options!
+        super *methods, options.reverse_merge(to: :object)
+      end
+    end
+  end
+end
+

data/lib/strong_presenter/factory.rb

@@ -0,0 +1,74 @@
+module StrongPresenter
+  class Factory
+    # Creates a presenter factory.
+    #
+    # @option options [Presenter, CollectionPresenter] :with (nil)
+    #   presenter class to use. If nil, it is inferred from the object
+    #   passed to {#wrap}.
+    def initialize(options = {})
+      options.assert_valid_keys(:with)
+      @presenter_class = options.delete(:with)
+    end
+
+    # Wraps an object with a presenter, inferring whether to create a singular or collection
+    # presenter from the type of object passed.
+    #
+    # @param [Object] object
+    #   object to present.
+    # @return [Presenter, CollectionPresenter] the presenter.
+    def wrap(object)
+      return nil if object.nil?
+      Worker.new(presenter_class, object).call { |presenter| yield presenter if block_given? }
+    end
+
+    private
+
+    attr_reader :presenter_class
+
+    # @private
+    class Worker
+      def initialize(presenter_class, object)
+        @presenter_class = presenter_class
+        @object = object
+        @presenter_class = presenter_class::Collection if collection? && !presenter_class.nil? && (presenter_class < StrongPresenter::Presenter)
+      end
+
+      def call
+        presenter.new(object) { |presenter| yield presenter if block_given? }
+      end
+
+      def presenter
+        return presenter_class if presenter_class
+        return object_presenter if object_presenter
+        return StrongPresenter::CollectionPresenter if collection?
+        raise StrongPresenter::UninferrablePresenterError.new(object.class)
+      end
+
+      private
+
+      attr_reader :presenter_class, :object
+
+      def object_presenter
+        @object_presenter = @object_presenter.nil? ? get_object_presenter : @object_presenter
+      end
+
+      def get_object_presenter
+        StrongPresenter::Presenter.inferred_presenter(object)
+      rescue NameError => error
+        false
+      end
+
+      def collection?
+        object.is_a?(Enumerable) or is_a?("ActiveRecord::Associations::CollectionProxy") # or any other wrappers
+      end
+
+      # Checks if object is an instance of klass, false in case klass does not exist.
+      def is_a? klass
+        object.is_a? klass.constantize
+      rescue NameError
+        false
+      end
+    end
+  end
+end
+

data/lib/strong_presenter/helper_proxy.rb

@@ -1,16 +1,34 @@
 module StrongPresenter
-  class HelperProxy < ActionView::Base
-    include Rails.application.routes.url_helpers
-
-    def method_missing method, *args, &block
-      if ApplicationController.helpers.respond_to? method
-        ApplicationController.helpers.public_send method, *args, &block
-      else
-        super
-      end
+  # Provides access to helper methods - both Rails built-in helpers, and those
+  # defined in your application.
+
+  # Copied from Draper::HelperProxy
+  class HelperProxy
+
+    # @overload initialize(view_context)
+    def initialize(view_context)
+      @view_context = view_context
     end
-    def respond_to? method, include_all = false
-      ApplicationController.helpers.respond_to?(method, include_all) or super
+
+    # Sends helper methods to the view context.
+    def method_missing(method, *args, &block)
+      self.class.define_proxy method
+      send(method, *args, &block)
+    end
+
+    delegate :capture, to: :view_context
+
+    protected
+
+    attr_reader :view_context
+
+    private
+
+    def self.define_proxy(name)
+      define_method name do |*args, &block|
+        view_context.send(name, *args, &block)
+      end
     end
+
   end
 end

data/lib/strong_presenter/inferrer.rb

@@ -0,0 +1,54 @@
+module StrongPresenter
+  # @private
+  # Helper class for inferring class names
+  class Inferrer
+    attr_accessor :input, :suffix
+
+    # Constructs inferer object
+    # @param [String] input
+    #   Input name as base to infer from
+    def initialize(input)
+      self.input = input
+    end
+
+    # Sets input suffix
+    # @param [String] suffix
+    #   Suffix which must be present in input to chomp/remove
+    # @return [self] chainable
+    def chomp(suffix)
+      self.suffix = suffix
+      self
+    end
+
+    # Extracts name by removing suffix
+    # @return [String]
+    def extract_name
+      raise UnextractableError if input.nil? || input.demodulize !~ /.+#{suffix}$/
+      input.chomp(suffix)
+    end
+
+    # Retrieve inferred class if it exists. If not, nil is returned.
+    # @yield (optional) for further transforming name
+    # @yieldparam [String] name after suffix removed
+    # @yieldreturn [String] name after transformation
+    # @return [Class] inferred class
+    def inferred_class
+      name = extract_name
+      name = yield name if block_given?
+      name.constantize
+    rescue NameError => error
+      raise unless Inferrer.missing_name?(error, name)
+      nil
+    end
+
+    protected
+    # Detect if error is due to inferred class not existing, or some other error
+    def self.missing_name?(error, name)
+      return true if error.is_a? UnextractableError
+      missing_name = error.missing_name
+      length = [missing_name.length, name.length].min
+      missing_name[-length..-1] == name[-length..-1]
+    end
+    class UnextractableError < NameError; end
+  end
+end

data/lib/strong_presenter/permissible.rb

@@ -0,0 +1,73 @@
+module StrongPresenter
+  module Permissible
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Permits all presenter attributes for presents, present & filter methods.
+      def permit!
+        define_method(:permitted_attributes){ @permitted_attributes ||= StrongPresenter::Permissions.new.permit_all! }
+      end
+    end
+
+    # Permits given attributes. May be invoked multiple times.
+    #
+    # @example Each argument represents a single attribute:
+    #   ArticlePresenter.new(@article).permit(:heading, :article)
+    #
+    # @example Attribute paths can be specified using symbol arrays. If an author name is normally accessed using @article.author.name:
+    #   ArticlePresenter.new(@article).permit([:author, :name])
+    #
+    # @param [[Symbols*]*] attribute_paths
+    #   the attributes to permit. An array of symbols represents an attribute path.
+    # @return [self]
+    def permit *attribute_paths
+      permitted_attributes.permit permissions_prefix, *attribute_paths
+      self
+    end
+
+    # Permits all presenter attributes for presents, present & filter methods.
+    def permit!
+      permitted_attributes.permit_all!
+      self
+    end
+
+    # Selects the attributes given which have been permitted - an array of attributes. Attributes are
+    # symbols, and attribute paths are arrays of symbols.
+    # @param [Array<Symbol>*] attribute_paths
+    #   the attribute paths to check. The attribute paths may also have arguments.
+    # @return [Array<Array<Symbol>, Symbol>] attribute (paths)
+    def filter *attribute_paths
+      select_permitted(*attribute_paths).map{ |attribute| attribute.first if attribute.size == 1 } # un-pack symbol if array with single symbol
+    end
+
+    protected
+    def permitted_attributes
+      @permitted_attributes ||= StrongPresenter::Permissions.new
+    end
+
+    # Selects the attributes given which have been permitted - an array of attributes
+    # Each returned attribute paths will be an array, even if it consists of only 1 symbol
+    # @param [Array<Symbols>*] attribute_paths
+    #   the attribute paths to check. The attribute paths may also have arguments.
+    # @return [Array<Array<Symbol>>] attribute (paths)
+    def select_permitted *attribute_paths
+      permitted_attributes.select_permitted permissions_prefix, *attribute_paths
+    end
+
+    # Links presenter to permissions group of given presenter.
+    # @param [Presenter] parent_presenter
+    # @param [Array<Symbol>] relative_path
+    #   The prefix prepended before every permission check relative to parent presenter.
+    def link_permissions parent_presenter, relative_path = []
+      self.permissions_prefix = parent_presenter.send(:permissions_prefix) + Array(relative_path)
+      @permitted_attributes = parent_presenter.send(:permitted_attributes).merge @permitted_attributes, permissions_prefix
+    end
+
+    private
+    attr_writer :permissions_prefix
+    def permissions_prefix
+      @permissions_prefix ||= []
+    end
+  end
+end
+