strong_presenter 0.0.1 → 0.1.0

data/lib/strong_presenter/permissions.rb

@@ -0,0 +1,138 @@
+module StrongPresenter
+  # @private
+  #
+  #   Storage format:
+  #     The permissions object is shared by collection presenters with its constituent presenters,
+  #     and it is also shared with all of its associations. Each attribute path is stored as an array
+  #     of symbols in a Set. There is one top level presenter - the one which initialized the
+  #     Permissions object.
+  #   
+  #     When a presenter checks for permissions, the attribute path relative to the top
+  #     presenter is prepended to each attribute path, and its existence checked in the Set.
+  #
+  #     Arguments can also be part of permissions control. They are simply additional elements in the attribute path array,
+  #     and need not be symbols. If they are symbols, there is no way for Permissions to know whether they
+  #     are part of the attribute path, or additional arguments. Only the presenter knows that.
+  class Permissions
+
+    # Checks whether everything is permitted.
+    #
+    # @return [Boolean]
+    def complete?
+      permitted_paths.include? [] and ((@permitted_paths = Set[[]] if permitted_paths.count > 1) or true)
+    end
+
+    # Permits everything
+    #
+    # @return self
+    def permit_all!
+      permitted_paths.clear
+      permitted_paths << []
+      self
+    end
+
+    # @overload permitted? prefix_path = nil, attribute_path
+    #
+    # Checks if the attribute path is permitted. This is the case if
+    # any array prefix has been permitted.
+    #
+    # @param [Symbol, Array<Symbol>] prefix_path
+    # @param [Symbol, Array<Symbol,Object>] attribute_path
+    # @return [Boolean]
+    def permitted? prefix_path, attribute_path = nil
+      raw_permitted? Array(prefix_path), Array(attribute_path)
+    end
+
+    # Selects the attribute paths which are permitted.
+    #
+    # @param [Array] prefix_path
+    #   namespace in which each of the given attribute paths are in
+    # @param [[Symbol, Array<Symbol,Object>]*] *attribute_paths
+    #   each attribute path is a symbol or array of symbols
+    # @return [Array<Symbol, Array<Symbol,Object>>] array of attribute paths permitted
+    def select_permitted prefix_path, *attribute_paths
+      raw_select_permitted Array(prefix_path), nested_array(attribute_paths)
+    end
+
+    # Rejects the attribute paths which are permitted. Opposite of select_permitted.
+    # Returns the attribute paths which are not permitted.
+    #
+    # @param [Array] prefix_path
+    #   namespace in which each of the given attribute paths are in
+    # @param [[Symbol, Array<Symbol,Object>]*] *attribute_paths
+    #   each attribute path is a symbol or array of symbols
+    # @return [Array<Symbol, Array<Symbol,Object>>] array of attribute paths remaining
+    def reject_permitted prefix_path, *attribute_paths
+      raw_reject_permitted Array(prefix_path), nested_array(attribute_paths)
+    end
+
+    # Permits some attribute paths
+    #
+    # @param [Array<Symbol>] prefix_path
+    #   path to prepend to each attribute path
+    # @param [[Symbol, Array<Symbol,Object>]*] *attribute_paths
+    def permit prefix_path, *attribute_paths
+      prefix_path = Array(prefix_path)
+      # don't permit if already permitted
+      raw_reject_permitted(prefix_path, nested_array(attribute_paths)).each do |attribute_path|
+        permitted_paths << prefix_path + attribute_path
+      end
+      self
+    end
+
+    # Merges the permissions from another Permissions object
+    #
+    # @param [Permissions] permissions
+    # @param [Array<Symbol>] prefix
+    #   prefix to prepend to paths in permissions
+    # @return self
+    def merge permissions, prefix = []
+      permitted_paths.merge permissions.permitted_paths.map{|path| prefix+path} if permissions.is_a? self.class
+      self
+    end
+
+    protected
+
+    def permitted_paths
+      @permitted_paths ||= Set.new
+    end
+
+    private
+    # We trust path parameters are arrays
+    def raw_permitted? prefix_path, attribute_path = nil # const - does not alter arguments
+      return true if complete?
+      permitted_partial?([], prefix_path + Array(attribute_path))
+    end
+
+    def raw_reject_permitted prefix_path, attribute_paths # const - does not alter arguments
+      return [] if raw_permitted? prefix_path
+      attribute_paths.reject do |attribute_path|
+        permitted_partial? prefix_path.dup, attribute_path
+      end
+    end
+
+    def raw_select_permitted prefix_path, attribute_paths # const - does not alter arguments
+      return attribute_paths if raw_permitted? prefix_path
+      attribute_paths.select do |attribute_path|
+        permitted_partial? prefix_path.dup, attribute_path
+      end
+    end
+
+    # For internal use, checks if permitted explicitly by a subpath of [prefix_path, attribute_partial+]
+    # where attribute_partial is a prefix of at least one symbol from attribute_part
+    # Caution: Will mutate prefix_path
+    def permitted_partial? prefix_path, attribute_path
+      !!Array(attribute_path).detect do |attr|
+        break unless attr.is_a? Symbol
+        prefix_path << attr
+        permitted_paths.include? prefix_path
+      end
+    end
+
+    # Ensures that every array element is an array
+    def nested_array array
+      array.map{|e|Array(e)}
+    end
+
+  end
+end

data/lib/strong_presenter/presenter.rb

@@ -0,0 +1,191 @@
+module StrongPresenter
+  class Presenter
+    include StrongPresenter::ViewHelpers
+    include StrongPresenter::Permissible
+    include StrongPresenter::Associable
+    include StrongPresenter::Delegation
+
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+
+    # Constructs the presenter, taking 1 argument for the object being wrapped. For example:
+    #
+    #   user_presenter = UserPresenter.new @user
+    #
+    # A block can also be passed to use the presenter. For example:
+    #
+    #   <% UserPresenter.new @user do |user_presenter| %>
+    #     Username: <%= user_presenter.username %>
+    #   <% end %>
+    #
+
+    def initialize(object)
+      @object = object
+      yield self if block_given?
+    end
+
+    # Performs mass presentation - if it is allowed, subject to `permit`. To permit all without checking, call `permit!` first.
+    #
+    # Presents and returns the result of each field in the argument list. If a block is given, then each result
+    # is passed to the block. Each field is presented by calling the method on the presenter.
+    #
+    #   user_presenter.presents :username, :email # returns [user_presenter.username, user_presenter.email]
+    #
+    # Or with two arguments, the name of the field is passed first:
+    #
+    #   <ul>
+    #     <% user_presenter.presents :username, :email, :address do |field, value| %>
+    #       <li><%= field.capitalize %>: <% value %></li>     
+    #     <% end %>
+    #   </ul>
+    #
+    # If only the presented value is desired, use `each`:
+    #
+    #   <% user_presenter.presents(:username, :email).each do |value| %>
+    #     <td><%= value %></td>
+    #   <% end %>
+    #
+    # A field can have arguments in an array:
+    #
+    #   user_presenter.presents :username, [:notifications, :unread] # returns [user_presenter.username, user_presenter.notifications(:unread)]
+    #
+    # Notice that this interface allows you to concisely put authorization logic in the controller, with a dumb view layer:
+    #
+    #   # app/controllers/users_controller.rb
+    #   class UsersController < ApplicationController
+    #     def visible_params
+    #       @visible_params ||= begin
+    #         field = [:username]
+    #         field << :email if can? :read_email, @user
+    #         field << :edit_link if can? :edit, @user
+    #       end
+    #     end
+    #     def show
+    #       @users_presenter = UserPresenter.wrap_each(User.all).permit!
+    #     end
+    #   end
+    #
+    #   # app/views/users/show.html.erb
+    #   <table>
+    #     <tr>
+    #       <% visible_params.each do |field| %>
+    #         <th><%= field %></th>
+    #       <% end %>
+    #     </tr>
+    #     <% @users_presenter.each do |user_presenter| %>
+    #       <tr>
+    #         <% user_presenter.presents(*visible_params).each do |value| %>
+    #           <td><%= value %></td>
+    #         <% end %>
+    #       </tr>
+    #     <% end %>
+    #   </table>
+    #
+    def presents *attributes
+      select_permitted(*attributes).map do |args|
+        obj = self # drill into associations
+        while (args.size > 1) && self.class.send(:presenter_associations).include?(args[0]) do
+          obj = obj.public_send args.slice!(0)
+        end
+        value = obj.public_send *args # call final method with args
+        yield args[0], value if block_given?
+        value
+      end
+    end
+
+    # Same as presents, but for a single attribute. The differences are:
+    #   - the return value is not in an Array
+    #   - passes the value only (without attribute key as the 1st argument) to a block
+    def present field
+      presents field do |key, value|
+        yield value if block_given?
+      end.first
+    end
+
+    delegate :to_s
+
+    # In case object is nil
+    delegate :present?, :blank?
+
+    # ActiveModel compatibility
+    # @private
+    def to_model
+      self
+    end
+
+    # @return [Hash] the object's attributes, sliced to only include those
+    # implemented by the presenter.
+    def attributes
+      object.attributes.select {|attribute, _| respond_to?(attribute) }
+    end
+
+    # ActiveModel compatibility
+    delegate :to_param, :to_partial_path
+
+    # ActiveModel compatibility
+    singleton_class.delegate :model_name, to: :object_class
+
+    protected
+    def object
+      @object
+    end
+
+    class << self
+      def inferred_presenter(object)
+        Inferrer.new(object.class.name).inferred_class { |name| "#{name}Presenter" } or raise StrongPresenter::UninferrablePresenterError.new(self)
+      end
+
+      protected
+      def alias_object_to_object_class_name
+        if object_class?
+          alias_method object_class.name.underscore, :object
+          private object_class.name.underscore
+        end
+      end
+
+      def set_presenter_collection
+        collection_presenter = get_collection_presenter
+        const_set "Collection", collection_presenter unless const_defined?("Collection")
+      end
+
+      private
+      def inherited(subclass)
+        subclass.alias_object_to_object_class_name
+        subclass.set_presenter_collection
+        super
+      end
+
+      def get_collection_presenter
+        collection_presenter = Inferrer.new(name).chomp("Presenter").inferred_class {|name| "#{name.pluralize}Presenter"}
+        return collection_presenter unless collection_presenter.nil? || collection_presenter == self
+        Class.new(StrongPresenter::CollectionPresenter).presents_with(self)
+      end
+
+      # Returns the source class corresponding to the presenter class, as set by
+      # {presents}, or as inferred from the presenter class name (e.g.
+      # `ProductPresenter` maps to `Product`).
+      #
+      # @return [Class] the source class that corresponds to this presenter.
+      def object_class
+        @object_class ||= Inferrer.new(name).chomp("Presenter").inferred_class or raise UninferrableSourceError.new(self)
+      end
+
+      # Checks whether this presenter class has a corresponding {object_class}.
+      def object_class?
+        !!(@object_class ||= Inferrer.new(name).chomp("Presenter").inferred_class)
+      rescue NameError
+        false
+      end
+
+      # Sets the model presented by the class
+      #
+      def presents name
+        @object_class = name.to_s.camelize.constantize
+        alias_object_to_object_class_name
+      end
+
+    end
+  end
+end
+

data/lib/strong_presenter/presenter_association.rb

@@ -0,0 +1,29 @@
+module StrongPresenter
+  # @private
+  class PresenterAssociation
+
+    def initialize(association, options, &block)
+      options.assert_valid_keys(:with, :scope)
+
+      @association = association
+
+      @scope = options.delete(:scope)
+      @block = block
+
+      @factory = StrongPresenter::Factory.new(options)
+    end
+
+    def wrap(parent)
+      associated = parent.send(:object).send(association)
+      associated = associated.send(scope) if scope
+
+      factory.wrap(associated) do |presenter|
+        parent.instance_exec presenter, &@block if @block
+      end
+    end
+
+    private
+    attr_reader :factory, :association, :scope
+
+  end
+end

data/lib/strong_presenter/presenter_helper_constructor.rb

@@ -0,0 +1,60 @@
+module StrongPresenter
+  # @private
+  # Defines helper methods in controllers to access instance variables as presenters
+  class PresenterHelperConstructor
+    # settings: controller to define in, presenter factory, block to execute, options for valid actions
+    def initialize(controller_class, block, options)
+      @controller_class = controller_class
+      @factory = StrongPresenter::Factory.new(options.slice!(:only, :except))
+      @block = block
+      @action_matcher = setup_action_matcher(options)
+    end
+
+    # Returns proc to check if action matches
+    def setup_action_matcher(options)
+      options.each { |k,v| options[k] = Array(v).map(&:to_sym) unless v.nil? }
+      ->(action) { (options[:only].nil? || options[:only].include?(action)) && (options[:except].nil? || !options[:except].include?(action)) }
+    end
+
+    # call to construct helper
+    def call(variable)
+      @object = "@#{variable}"
+      @presenter = "@#{variable}_presenter"
+      construct(variable)
+    end
+
+    private
+    attr_accessor :controller_class, :factory, :presenter, :block
+
+    # actually construct the helper
+    def construct(variable)
+      shadowed_method = get_shadow_method(variable)
+      action_matcher = @action_matcher
+      memoized_presenter = method(:memoized_presenter).to_proc
+
+      controller_class.send :define_method, variable do |*args|
+        return shadowed_method.call self, *args unless action_matcher.call(action_name.to_sym) # scoped by controller action?
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)") unless args.empty?
+        memoized_presenter.call(self)
+      end
+    end
+
+    # method which will be shadowed by the defined helper
+    def get_shadow_method(method_name) # alias_method_chain without name pollution
+      shadowed_method = controller_class.send :instance_method, method_name if controller_class.send :method_defined?, method_name
+      return lambda { |obj, *args| raise NoMethodError } if shadowed_method.nil?
+      return lambda { |obj, *args| shadowed_method.bind(obj).call(*args) }
+    end
+
+    # get presenter, memoized
+    def memoized_presenter(controller)
+      return controller.send(:instance_variable_get, presenter) if controller.send(:instance_variable_defined?, presenter)
+      controller.send(:instance_variable_set, presenter, wrapped_object(controller))
+    end
+
+    # wrap model with presenter and return
+    def wrapped_object(controller)
+      factory.wrap(controller.send :instance_variable_get, @object) { |presenter| self.instance_exec presenter, &block }
+    end
+  end
+end

data/lib/strong_presenter/railtie.rb

@@ -1,9 +1,33 @@
 module StrongPresenter
   class Railtie < Rails::Railtie
-    initializer "setup_helper_proxy" do |app|
-      ActiveSupport.on_load :action_controller do
-        require 'strong_presenter/helper_proxy' # a hack currently
+
+    config.after_initialize do |app|
+      app.config.paths.add 'app/presenters', eager_load: true
+
+      if Rails.env.test?
+        require 'strong_presenter/test_case'
+        require 'strong_presenter/test/rspec_integration' if defined?(RSpec) and RSpec.respond_to?(:configure)
+        require 'strong_presenter/test/minitest_integration' if defined?(MiniTest::Rails)
       end
     end
+
+    [:action_controller, :action_mailer, :active_model_serializers].each do |klass|
+      initializer "strong_presenter.setup_#{klass}" do |app|
+        ActiveSupport.on_load klass do
+          StrongPresenter.send "setup_#{klass}", self
+        end
+      end
+    end
+
+    console do
+      require 'action_controller/test_case'
+      ApplicationController.new.view_context
+      StrongPresenter::ViewContext.build
+    end
+
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__),'tasks/*.rake')].each { |f| load f }
+    end
+
   end
 end

data/lib/strong_presenter/tasks/test.rake

@@ -0,0 +1,22 @@
+require 'rake/testtask'
+
+test_task = if Rails.version.to_f < 3.2
+  require 'rails/test_unit/railtie'
+  Rake::TestTask
+else
+  require 'rails/test_unit/sub_test_task'
+  Rails::SubTestTask
+end
+
+namespace :test do
+  test_task.new(:presenters => "test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = "test/presenters/**/*_test.rb"
+  end
+end
+
+if Rake::Task.task_defined?('test:run')
+  Rake::Task['test:run'].enhance do
+    Rake::Task['test:presenters'].invoke
+  end
+end

data/lib/strong_presenter/test/devise_helper.rb

@@ -0,0 +1,30 @@
+module StrongPresenter
+  module DeviseHelper
+    def sign_in(resource_or_scope, resource = nil)
+      scope = begin
+        Devise::Mapping.find_scope!(resource_or_scope)
+      rescue RuntimeError => e
+        # Draper 1.0 didn't require the mapping to exist
+        ActiveSupport::Deprecation.warn("#{e.message}.\nUse `sign_in :user, mock_user` instead.", caller)
+        :user
+      end
+
+      _stub_current_scope scope, resource || resource_or_scope
+    end
+
+    def sign_out(resource_or_scope)
+      scope = Devise::Mapping.find_scope!(resource_or_scope)
+      _stub_current_scope scope, nil
+    end
+
+    private
+
+    def _stub_current_scope(scope, resource)
+      StrongPresenter::ViewContext.current.controller.singleton_class.class_eval do
+        define_method "current_#{scope}" do
+          resource
+        end
+      end
+    end
+  end
+end

data/lib/strong_presenter/test/minitest_integration.rb

@@ -0,0 +1,6 @@
+class StrongPresenter::TestCase
+  register_spec_type(self) do |desc|
+    desc < StrongPresenter::Presenter || desc < StrongPresenter::CollectionPresenter if desc.is_a?(Class)
+  end
+  register_spec_type(/Presenter( ?Test)?\z/i, self)
+end

data/lib/strong_presenter/test/rspec_integration.rb

@@ -0,0 +1,16 @@
+module StrongPresenter
+  module PresenterExampleGroup
+    include StrongPresenter::TestCase::Behavior
+    extend ActiveSupport::Concern
+
+    included { metadata[:type] = :presenter }
+  end
+
+  RSpec.configure do |config|
+    config.include PresenterExampleGroup, example_group: {file_path: %r{spec/presenters}}, type: :presenter
+
+    [:presenter, :controller, :mailer].each do |type|
+      config.before(:each, type: type) { StrongPresenter::ViewContext.clear! }
+    end
+  end
+end

data/lib/strong_presenter/test_case.rb

@@ -0,0 +1,53 @@
+module StrongPresenter
+  begin
+    require 'minitest/rails'
+  rescue LoadError
+  end
+
+  active_support_test_case = begin
+    require 'minitest/rails/active_support' # minitest-rails < 0.5
+    ::MiniTest::Rails::ActiveSupport::TestCase
+  rescue LoadError
+    require 'active_support/test_case'
+    ::ActiveSupport::TestCase
+  end
+
+  class TestCase < active_support_test_case
+    module ViewContextTeardown
+      def teardown
+        super
+        StrongPresenter::ViewContext.clear!
+      end
+    end
+
+    module Behavior
+      if defined?(::Devise)
+        require 'strong_presenter/test/devise_helper'
+        include StrongPresenter::DeviseHelper
+      end
+
+      if defined?(::Capybara) && (defined?(::RSpec) || defined?(::MiniTest::Matchers))
+        require 'capybara/rspec/matchers'
+        include ::Capybara::RSpecMatchers
+      end
+
+      include StrongPresenter::ViewHelpers::ClassMethods
+      alias_method :helper, :helpers
+    end
+
+    include Behavior
+    include ViewContextTeardown
+  end
+end
+
+if defined?(ActionController::TestCase)
+  class ActionController::TestCase
+    include StrongPresenter::TestCase::ViewContextTeardown
+  end
+end
+
+if defined?(ActionMailer::TestCase)
+  class ActionMailer::TestCase
+    include StrongPresenter::TestCase::ViewContextTeardown
+  end
+end

data/lib/strong_presenter/version.rb

@@ -1,3 +1,3 @@
 module StrongPresenter
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/strong_presenter/view_context/build_strategy.rb

@@ -0,0 +1,48 @@
+module StrongPresenter
+  module ViewContext
+    # @private
+    module BuildStrategy
+
+      def self.new(name, &block)
+        const_get(name.to_s.camelize).new(&block)
+      end
+
+      class Fast
+        def initialize(&block)
+          @view_context_class = Class.new(ActionView::Base, &block)
+        end
+
+        def call
+          view_context_class.new
+        end
+
+        private
+
+        attr_reader :view_context_class
+      end
+
+      class Full
+        def initialize(&block)
+          @block = block
+        end
+
+        def call
+          controller.view_context.tap do |context|
+            context.singleton_class.class_eval(&block) if block
+          end
+        end
+
+        private
+
+        attr_reader :block
+
+        def controller
+          (StrongPresenter::ViewContext.controller || ApplicationController.new).tap do |controller|
+            controller.request ||= ActionController::TestRequest.new if defined?(ActionController::TestRequest)
+          end
+        end
+      end
+
+    end
+  end
+end