context_exposer 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cff7846013a27d16f62e455b571af3336ea88531
-  data.tar.gz: d7b782a83befc4da2b8ffa9a145eff505734d303
+  metadata.gz: 636d3dfdd4dc2b214e8f8b4b21be110979c458b2
+  data.tar.gz: 1ee51b21d57d43d0320a7096445c6bfe1609b6a1
 SHA512:
-  metadata.gz: 47926e8db084652454e11b10b82e949618809ed3a1b9141c98b5830dae93a5e771fe79aca837a7a1520062710b9c3fe5f4a7cf63366942048db414391b7e1f36
-  data.tar.gz: 191e35391a9271b9cc3a3dea8e2429fee8ebb0c6788ade0feb2f9c449303c280fc6bcf26c3d2bf3151db1dcc94db809fff341c87fcd9a91a0717a885785e7553
+  metadata.gz: 093d90e0c742c7516b8dfd3caba617758a0d7ba7febcd5ea129b9552e262c8a9583cd8b4a6652ff514039557bafb96b6565baf69f81f19117846706ad801fb82
+  data.tar.gz: 5607a5cacf2b0ba969b498dd61d4a0e4b2a6dc6debe90b000907dd6bc05c32470f648e4b7d80999210a2cbc605e61e731637325653d40d9a4f47545e44998ac1

data/README.md

@@ -12,6 +12,7 @@ The gem comes with integrations ready for easy migration or symbiosis with exist
 * exposing of instance variables (Rails default strategy)
 * decent_exposure gem (expose methods)
 * decorates_before_rendering gem (expose decorated instance vars)
+* draper
 
 For more on integration (and migration path) see below ;)
 
@@ -98,7 +99,7 @@ class PostsController < ActionController::Base
   exposed(:posts)       { Post.all } 
 
   # Array of model instances
-  exposed(:posts_list)  { Post.all.to_a } 
+  exposed(:post_list)   { Post.all.to_a } 
 end
 ```
 
@@ -148,7 +149,7 @@ The `ResourceController` automatically sets up the typical singular and plural-f
 
 * `post` - one Post instance
 * `posts` - Search Relatation (for lazy load or further scoping)
-* `posts_list` - Array of Post instances
+* `post_list` - Array of Post instances
 
 This simplifies the above `PostsController` example to this:
 
@@ -161,7 +162,7 @@ class PostsController < ActionController::Base
 end
 ```
 
-The macro `expose_resources` optionally takes a list of the types of resource you want to expose. Valid types are `:one`, `:many` and `:list` respectively (for fx: `post`, `posts` and `posts_list`).
+The macro `expose_resources` optionally takes a list of the types of resource you want to expose. Valid types are `:one`, `:many` and `:list` respectively (for fx: `post`, `posts` and `post_list`).
 
 `ContextExposer::ResourceController`  uses the following internal logic for its default functionality. You can override these methods to customize your behavior as needed.
 
@@ -264,6 +265,23 @@ HAML view example
   %h2 = post.name
 ```
 
+## Draper
+
+The `draper` gem adds a `decorates_assigned` method since version *1.1* (see [pull request](https://github.com/drapergem/draper/pull/461)).
+
+```ruby
+decorates_assigned :article, with: FancyArticleDecorator
+decorates_assigned :articles, with: PaginatingCollectionDecorator
+```
+
+Since this functionality is very similar to fx `decent_exposure`, it can be used with `ctx` in a similar way. Simply use the `context_expose_assigned` macro.
+
+`context_expose_assigned :post, :posts`
+
+In the near future there should be even better integration, so you don't have to specify the method names to expose all, just like for `context_expose_decently` ;)
+
+See [commit comment](https://github.com/haines/draper/commit/afa97bb401666f47ef380d7c9e8e94a8b472597d#commitcomment-2844631)
+
 ## Decorates before rendering
 
 A patch for the `decorates_before_render` gem is currently made available.
@@ -306,6 +324,78 @@ end
 
 If the auto-decoration can't find a decorator for an exposed variable (or method), it will either ignore it (not decorate it) or call `__handle_decorate_error_(error)` which by default will log a Rails warning. Override this error handler as it suits you.
 
+## Globalizing the page context
+
+As you have the `ctx` object encapsulate all the view state in one place, you can simplify
+your partial calls to `render partial: 'my/partial/template', locals: {ctx: ctx}`.
+However, if you use nested partials it quickly feels repetitive...
+
+Which is why this pattern is now encapsulated in the view helper `render_ctx` which auto-populates the `:locals` hash with a local `page_context` variable that points to a `ContextExposer::PageContext.instance` which contains the `ctx` object :)
+
+Furthermore, a delegation of `ctx` to  `page_context.ctx` is defined so you can still access `ctx` directly from within the views.
+
+So you then only have to use the locals hash if you want to pass on variables not part of `ctx`.
+
+```ruby
+render_ctx partial: 'my/partial/template'
+```
+
+### Page object
+
+To further help in making page rendering decissions, a `ContextExposer::Page` instance is 
+created and populated on each request, which can contain the following data:
+
+`:name, :id, :action, :mode, :controller_name, :type, :resource`
+
+The Page instance will attempt to calculate the resource name from the `normalized_resource_name` method of the `ContextExposer::BaseController`. Override this method to calculate a custom resource name for the controller.
+
+The page name will normally be calculated by concatenating action, resource name and type, so a `PostController#show` action will have the default name `'show_post_item'`. Resource `type` is either `:list` or `:item` and will be attempted calculated using the action name and looking up in the `list_actions` and `item_actions` class methods on the controller.
+
+By default these methods will use the `base_list_actions` (index) and `base_item_actions` (show, new, edit). You can override/extend these conventions and provide your own `list_actions` and `item_actions` class methods for each controller. Macros are provided to generate these methods from a simple list.
+
+```ruby
+class Admin::BirdLocationController < ActionController::Base
+  # expose, decorate etc left out
+
+  # use macros to configure extra REST-like actions
+  list_actions :manage
+  item_actions :map
+
+  # custom page object config just before render
+  after_filter :set_page_mode
+
+  # manage many birds
+  def manage
+    Bird.all
+  end
+
+  # show a single bird location on the map
+  def map
+    Bird.find params[:id]
+  end
+
+  protected
+
+  def set_page_mode
+    ctx.page.mode = mode
+  end
+
+  # custom calculated page name using fx action_name method and params etc
+  def page_name
+    "#{action_name}_#{mode}"
+  end
+
+  # map, details or normal mode ?
+  def mode
+    params[:mode]
+  end
+
+  def self.normalized_resource_name
+    :bird
+  end
+end
+```
+
 ## Testing
 
 The tests have been written in rspec 2 and capybara. 

data/lib/context_exposer/base_controller.rb

@@ -8,6 +8,8 @@ module ContextExposer::BaseController
     # before_filter :configure_exposed_context
     set_callback :process_action, :before, :configure_exposed_context
 
+    set_callback :process_action, :after,  :save_exposed_context
+
     expose_context :ctx
   end
 
@@ -17,6 +19,10 @@ module ContextExposer::BaseController
   alias_method :ctx, :view_ctx
 
   module ClassMethods
+    def normalized_resource_name
+      self.to_s.demodulize.sub(/Controller$/, '').underscore.singularize
+    end
+
     def exposed name, options = {}, &block
       _exposure_storage[name.to_sym] = {options: options, proc: block}
     end
@@ -31,6 +37,30 @@ module ContextExposer::BaseController
       end
     end
 
+    def base_list_actions
+      [:index]
+    end
+
+    def base_item_actions
+      [:show, :new, :edit]
+    end
+
+    def list_actions *names
+      return if names.blank?
+      names = names.flatten.map(&:to_sym)
+      (class << self; end).define_method :list_actions do
+        names | base_list_actions
+      end
+    end
+
+    def item_actions *names
+      return if names.blank?
+      names = names.flatten.map(&:to_sym)
+      (class << self; end).define_method :item_actions do
+        names | base_item_actions
+      end
+    end
+
     def integrate_with *names
       names.flatten.compact.each do |name|
         self.send :include, "ContextExposer::Integrations::With#{name.to_s.camelize}".constantize
@@ -83,6 +113,56 @@ module ContextExposer::BaseController
     @configured_exposed_context = true
   end
 
+  def save_exposed_context
+    ContextExposer::PageContext.instance.configure ctx, page_obj
+  end
+
+  def page_obj
+    @page ||= build_page_obj
+  end
+
+  # TODO: cleanup!
+  def build_page_obj
+    return @page if @page
+    @page = ContextExposer::Page.instance
+    @page.clear!
+    clazz = self.class
+
+    # single or list resource ?
+    @page.resource.type = calc_resource_type if calc_resource_type
+
+    # also attempts to auto-caluclate resource.type if not set
+    @page.resource.name = if clazz.respond_to?(:normalized_resource_name, true)
+      clazz.normalized_resource_name 
+    else
+      clazz.resource_name if clazz.respond_to?(:resource_name, true)
+    end
+
+    @page.controller = self
+
+    @page.name = if respond_to?(:page_name, true)
+       page_name 
+    else
+      @page_name if @page_name
+    end
+
+    @page
+  end
+
+  def calc_resource_type
+    return @resource_type if @resource_type
+    clazz = self.class
+
+    if clazz.respond_to?(:list_actions, true) && !clazz.list_actions.blank?
+      resource_type = :list if clazz.list_actions[action_name.to_sym]
+    end
+
+    if !resource_type && clazz.respond_to?(:item_actions, true) && !clazz.item_actions.blank?
+      resource_type = :item if clazz.item_actions[action_name.to_sym] 
+    end
+    @resource_type = resource_type
+  end    
+
   def configured_exposed_context?
     @configured_exposed_context == true
   end

data/lib/context_exposer/core_ext/string.rb

@@ -0,0 +1,13 @@
+module PluralTester
+  def singular?
+    self.pluralize.singularize == self
+  end
+
+  def plural?
+    self.singularize.pluralize == self
+  end
+end
+
+class String
+  include PluralTester
+end

data/lib/context_exposer/integrations/with_draper.rb

@@ -0,0 +1,22 @@
+module ContextExposer::Integrations
+  module WithDecentExposure
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # expose all exposures exposed by decent_exposure to context
+      def context_expose_assigned *names
+        options = names.extract_options!
+        expose_keys = names
+        expose_keys = _assigned.keys if expose_keys.empty? && respond_to? :_assigned
+        return if expose_keys.blank?
+
+        _exposure_filter(expose_keys, options).each do |exposure|
+          exposed exposure do
+            send(exposure)
+          end
+        end
+      end
+      alias_method :expose_decently, :context_expose_decently       
+    end
+  end
+end

data/lib/context_exposer/page/resource.rb

@@ -0,0 +1,49 @@
+module ContextExposer
+  class Page
+    class Resource
+      attr_accessor :name, :type, :controller
+
+      def initialize name = nil, type = nil        
+        self.name = name
+        self.type = type if type
+      end
+
+      def type= type
+        validate_type! type
+        @type = type.to_sym
+      end
+
+      def name= name    
+        @name = name.to_s    
+        unless @type
+          @type = calc_type 
+        end
+      end
+
+      protected
+
+      def page_context
+        ContextExposer::PageContext.instance
+      end
+
+      def calc_type
+        return nil if name.blank?
+        name.to_s.plural? ? :list : :item
+      end
+
+      def validate_type! type
+        unless valid_type? type
+          raise ArgumentError, "type must be one of: #{valid_types}, was: #{type}"
+        end
+      end
+
+      def valid_type? type
+        valid_types.include? type.to_sym
+      end
+
+      def valid_types
+        [:list, :item]
+      end
+    end
+  end
+end

data/lib/context_exposer/page.rb

@@ -0,0 +1,44 @@
+require 'context_exposer/page/resource'
+
+module ContextExposer
+  class Page
+    include Singleton
+
+    attr_accessor :name, :id, :action, :mode, :controller_name, :type, :resource
+
+    def configure name = nil, options = {}
+      self.name = name
+      self.type = options[:type]
+      self.resource.name = options[:resource_name]
+      self.resource.type = options[:resource_type]
+    end
+
+    def clear!
+      instance_variables.each do |inst_var|
+        var = inst_var.to_s.sub('@', '')
+        self.send("#{var}=", nil)
+      end
+    end
+
+    # action= 'show', resource.name = 'post' and resource.type = :item
+    #   show_post_item 
+    # action= 'manage', resource.name = 'post' and resource.type = :list
+    #   manage_post_list
+    def name
+      @name ||= [action, resource.name, resource.type].compact.map(&:to_s).join('_').underscore
+    end
+
+    def controller= controller
+      @action = controller.action_name
+      @controller_name = controller.controller_name    
+    end
+
+    def resource
+      @resource ||= Resource.new
+    end
+
+    def map?
+      false
+    end
+  end
+end

data/lib/context_exposer/page_context.rb

@@ -0,0 +1,27 @@
+module ContextExposer
+  class PageContext
+    include Singleton
+
+    attr_accessor :ctx
+
+    def configure ctx, page = nil
+      self.ctx = ctx
+      self.page = page if page
+    end
+
+    def ctx= ctx
+      unless ctx.kind_of? ContextExposer::ViewContext
+        raise ArgumentErorr, "Must be a kind of ContextExposer::ViewContext, was: #{ctx}"
+      end
+      @ctx = ctx 
+    end
+
+    def page= page
+      ctx.page = page
+    end
+
+    def page
+      ctx.page if ctx
+    end
+  end
+end

data/lib/context_exposer/patch/decorates_before_rendering.rb

@@ -2,11 +2,15 @@ module DecoratesBeforeRendering
   class FindModelError < StandardError; end
   class DecoratorError < StandardError; end
 
-  def render *args
-    __auto_decorate_exposed_ones_
-    super(*args)
+  included do
+    after_filter :__auto_decorate_exposed_ones_
   end
 
+  # def render *args
+  #   __auto_decorate_exposed_ones_
+  #   super(*args)
+  # end
+
   def __auto_decorate_exposed_ones_
     __decorate_ivars__
     __decorate_exposed_ones_
@@ -17,27 +21,41 @@ module DecoratesBeforeRendering
 
   def __handle_decorate_error_ e 
     # puts "Error: #{e}"
-
     if defined?(::Rails) && (Rails.respond_to? :logger)
       Rails.logger.warn 'decorates_before_render: auto_decorate error: #{e}'
     end
   end
 
   def __exposed_ones_
-    return [] unless self.class.respond_to? :_exposures
-    @__exposed_ones_ ||= self.class._exposures.keys
+    return [] unless _has_exposures?
+    @__exposed_ones_ ||= _exposure_keys
+  end
+
+  def _exposure_keys
+    self.class._exposures.keys
+  end
+
+  def _has_exposures?
+    self.class.respond_to? :_exposures
   end
 
   def __ctx_exposed_ones_
-    return [] unless self.class.respond_to? :_exposure_storage
-    @__ctx_exposed_ones_ ||= self.class._exposure_storage.keys
+    return [] unless _has_exposure_storage?
+    @__ctx_exposed_ones_ ||= _cxt_exposed_keys
+  end
+
+  def _cxt_exposed_keys
+    self.class._exposure_storage.keys
+  end
+
+  def _has_exposure_storage?
+    self.class.respond_to? :_exposure_storage
   end
 
   def __decorate_exposed_ones_
     __exposed_ones_.each do |name|
       ivar_name = "@#{name}"
-      obj = send(name)
-      decorated = __attempt_to_decorate_(obj)
+      objs = send(name)
 
       decorated = case objs
       when Array
@@ -73,6 +91,7 @@ module DecoratesBeforeRendering
   end
 
   def __attempt_to_decorate_ obj
+    return obj if obj.respond_to?(:decorate)
     if obj
       src = __src_for__(obj)
       decorator = __normalized_decorator_for__(src)
@@ -81,6 +100,8 @@ module DecoratesBeforeRendering
   end    
 
   def __do_decoration_ decorator, obj
+    return obj if obj.respond_to?(:decorate)
+
     return if !decorator || !obj
     __validate_decorator!(decorator)
     decorator.decorate(obj)
@@ -136,18 +157,13 @@ module DecoratesBeforeRendering
   end  
 
   def __decorate_ivars__
+    return unless __has_decorates?
     __validate_decorates_present_
     return if __decorates_blank?
     __decorates__ivars
     __decorates_collection_ivars__
   end
 
-  def __validate_decorates_present_
-    unless __has_decorates?
-      raise "Internal method '__decorates__' not found. You need to include the 'decorates_before_render' gem " 
-    end
-  end
-
   def __has_decorates?
     respond_to?(:__decorates__)
   end

data/lib/context_exposer/resource_controller.rb

@@ -14,15 +14,15 @@ module ContextExposer::ResourceController
       types = types.empty? ? [:all] : types
 
       unless expose_resource_method? :one, types
-        _exposing(_normalized_resource_name.singularize)  { find_single_resource    }
+        _exposing(normalized_resource_name.singularize)  { find_single_resource    }
       end
 
       unless expose_resource_method? :many, types
-        _exposing(_normalized_resource_name.pluralize)    { find_all_resources      }
+        _exposing(normalized_resource_name.pluralize)    { find_all_resources      }
       end
 
       unless expose_resource_method? :list, types
-        _exposing(_normalized_resource_list)              { find_all_resources.to_a }
+        _exposing(normalized_resource_list)              { find_all_resources.to_a }
       end
     end    
 
@@ -57,12 +57,8 @@ module ContextExposer::ResourceController
       raise "Resource #{clazz_name} is not defined. #{e}"
     end
 
-    def _normalized_resource_list
-      _normalized_resource_name.pluralize + '_list'
-    end
-
-    def _normalized_resource_name
-      self.to_s.demodulize.sub(/Controller$/, '').underscore
+    def normalized_resource_list
+      normalized_resource_name.singularize + '_list'
     end
   end
 end

data/lib/context_exposer/version.rb

@@ -1,3 +1,3 @@
 module ContextExposer
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/context_exposer/view_context.rb

@@ -1,12 +1,31 @@
 class ContextExposer::ViewContext
-  attr_reader :controller
+  attr_reader   :controller
+  attr_accessor :page
 
-  def initialize controller = nil
+  def initialize controller = nil, page = nil
     @controller = controller
+    self.page   = page if page
+  end
+
+  def page= page
+    validate_page! page
+    @page = page
   end
 
   protected
 
+  def validate_page! page
+    raise ArgumentError, "Must be a kind of #{valid_page_class}, was: #{page}" unless valid_page? page
+  end
+
+  def valid_page? page
+    page.kind_of? valid_page_class
+  end
+
+  def valid_page_class
+    ContextExposer::Page
+  end
+
   def define_singleton_method(name, &block)
     eigenclass = class<<self; self end
     eigenclass.class_eval {define_method name, block}

data/lib/context_exposer/view_helpers.rb

@@ -0,0 +1,15 @@
+module ContextExposer
+  module ViewHelpers
+    def render_ctx *args
+      opts = args.last
+      if opts.kind_of?(Hash) && opts[:locals]
+        args.last[:locals].merge!(page_context: ContextExposer::PageContext.instance)
+      end
+      super *args
+    end
+
+    def ctx
+      page_context.ctx
+    end
+  end
+end

data/lib/context_exposer.rb

@@ -16,9 +16,15 @@ module ContextExposer
 end
 
 require "active_support"
+require "context_exposer/core_ext/string"
 require "context_exposer/base_controller"
 require "context_exposer/resource_controller"
 require "context_exposer/cached_resource_controller"
 require "context_exposer/view_context"
 require "context_exposer/macros"
 require "context_exposer/rails_config"
+
+require 'singleton'
+require "context_exposer/page_context"
+require "context_exposer/page"
+require "context_exposer/view_helpers"

data/spec/context_exposer/expose_resource_spec.rb

@@ -14,6 +14,8 @@ class PostsController < ActionController::Base
   end
 
   def index
+    configure_exposed_context
+    render
   end
 
   protected
@@ -72,8 +74,8 @@ describe ContextExposer::ResourceController do
           expect(subject).to respond_to(:posts)
         end      
 
-        it "defines a method :posts_list" do
-          expect(subject).to respond_to(:posts_list)
+        it "defines a method :post_list" do
+          expect(subject).to respond_to(:post_list)
         end      
 
         context 'post' do
@@ -93,14 +95,22 @@ describe ContextExposer::ResourceController do
           subject     { posts }
           let(:posts) { ctx.posts }
 
+          before :each do        
+            controller.index
+          end
+
           it "calling method :posts returns all posts " do
             expect(subject).to eq [@post1, @post2]
           end    
         end
 
-        context 'posts_list' do
-          subject          { posts_list }
-          let(:posts_list) { ctx.posts_list }
+        context 'post_list' do
+          subject         { post_list }
+          let(:post_list) { ctx.post_list }
+
+          before :each do        
+            controller.index
+          end
 
           it "calling method :posts_list returns all posts " do
             expect(subject).to eq [@post1, @post2]

data/spec/context_exposer/expose_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-class MyController < ActionController::Base
+class BirdController < ActionController::Base
   include ContextExposer::BaseController
   
   exposed(:bird) { "Bird" }
@@ -16,9 +16,18 @@ class MyController < ActionController::Base
 
   def show
     configure_exposed_context
+    save_exposed_context
+  end
+
+  def action_name
+    'show'
   end
 
   protected
+
+  def self.resource_name
+    :bird
+  end
 end
 
 class MyCoolController < ActionController::Base
@@ -30,10 +39,19 @@ class MyCoolController < ActionController::Base
 
   def show
     configure_exposed_context
+    save_exposed_context
+  end
+
+  def action_name
+    'show'
   end
 
   protected
 
+  def self.resource_name
+    "MyCool"
+  end
+
   def params; end  
 end
 
@@ -52,7 +70,7 @@ describe ContextExposer::BaseController do
   describe "controller" do
     subject { controller }
 
-    let(:controller) { MyController.new }
+    let(:controller) { BirdController.new }
 
     # run action post
     before :each do
@@ -79,7 +97,7 @@ describe ContextExposer::BaseController do
       expect(subject.configured_exposed_context?).to be_true
     end
 
-    context 'context' do
+    context 'ctx' do
       subject { controller.ctx }
 
       it "is an instance of ContextExposer::ViewContext" do
@@ -102,6 +120,54 @@ describe ContextExposer::BaseController do
         expect(subject.bird).to eq "Bird"
       end      
     end
+
+    context 'PageContext' do
+      subject { page_context }
+
+      let(:page_context) { ContextExposer::PageContext.instance }
+
+      it "has a page" do
+        expect(subject.page).to be_a ContextExposer::Page
+      end            
+
+      it "has a ctx" do
+        expect(subject.ctx).to be_a ContextExposer::ViewContext
+      end      
+
+      context 'page' do
+        subject    { page }
+
+        let(:page) { page_context.page }
+
+        it "has a name" do
+          expect(subject.name).to eq "show_bird_item"
+        end              
+
+        it "has a type" do
+          expect(subject.type).to eq nil
+        end              
+
+        it "has an action" do
+          expect(subject.action).to eq 'show'
+        end              
+
+        it "has a resource" do
+          expect(subject.resource).to be_a ContextExposer::Page::Resource
+        end              
+
+        context 'resource' do
+          subject { page.resource }
+
+          it "has a name" do
+            expect(subject.name).to eq 'bird'
+          end              
+
+          it "has a type" do
+            expect(subject.type).to eq :item
+          end              
+        end
+      end      
+    end
   end
 
   describe 'MyCoolController' do
@@ -114,7 +180,7 @@ describe ContextExposer::BaseController do
       controller.show
     end
 
-    context 'context' do
+    context 'ctx' do
       subject { controller.ctx }
 
       it "inherits from ContextExposer::ViewContext" do

data/spec/dummy/app/views/items/index.html.erb

@@ -1,2 +1,2 @@
 <h1>Items</h1>
-<%= ctx.items_list.map {|i| i.nice_name }.inspect %>
+<%= ctx.item_list.map {|i| i.nice_name }.inspect %>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: context_exposer
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kristian Mandrup
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-17 00:00:00.000000000 Z
+date: 2013-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,18 +56,24 @@ files:
 - lib/context_exposer.rb
 - lib/context_exposer/base_controller.rb
 - lib/context_exposer/cached_resource_controller.rb
+- lib/context_exposer/core_ext/string.rb
 - lib/context_exposer/integrations.rb
 - lib/context_exposer/integrations/base.rb
 - lib/context_exposer/integrations/key_filter.rb
 - lib/context_exposer/integrations/with_decent_exposure.rb
 - lib/context_exposer/integrations/with_decorates_before.rb
+- lib/context_exposer/integrations/with_draper.rb
 - lib/context_exposer/integrations/with_instance_vars.rb
 - lib/context_exposer/macros.rb
+- lib/context_exposer/page.rb
+- lib/context_exposer/page/resource.rb
+- lib/context_exposer/page_context.rb
 - lib/context_exposer/patch/decorates_before_rendering.rb
 - lib/context_exposer/rails_config.rb
 - lib/context_exposer/resource_controller.rb
 - lib/context_exposer/version.rb
 - lib/context_exposer/view_context.rb
+- lib/context_exposer/view_helpers.rb
 - spec/app/items_spec.rb
 - spec/app/posts_spec.rb
 - spec/context_exposer/expose_resource_spec.rb