context_exposer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12da37ed9022c53dd944d8c73f53c0da2980a65f
+  data.tar.gz: 7cd49fd373d8ea82633f36064c21eb95303e3ab4
+SHA512:
+  metadata.gz: 4cc5284dce7e9ac8c4d9afd9470cbd69e6f29f2bcc2c75749439ad195a86326e9848dd292db2cc1e8f2d31641eee89d28198e43620d295fe930a39bb631524a9
+  data.tar.gz: 92d81c8be3d0dd2dd4e067f3c3c1a73837319d01ffeaaba0a2c4f29890e89caaa75960b7650994ade13f545c0446339bcc69f3aa57428679500d14e94d293b61

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color --format nested

data/Gemfile

@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in context_exposer.gemspec
+gemspec
+
+gem 'pry'
+gem 'rails', '>= 3.1'
+
+gem "rspec-rails", :group => [:test, :development]
+
+group :test do
+  # gem 'factory_girl_rails', :require => false
+  # gem "capybara"
+  # gem "capybara-webkit"
+  # gem 'growl'  
+  # gem "spork"
+  # gem "guard"
+  # gem "guard-bundler"
+  # gem "guard-rspec"
+  # gem "guard-spork"
+  # gem "launchy"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kristian Mandrup
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,111 @@
+# ContextExposer
+
+Allows the Controller to exposes a Context object to the View. 
+This Context object alone contains all the information passed to the View from the controller. 
+
+No more pollution of the View with content helper methods or even worse, instance variables.
+
+The Context object will by default be an instance of `ContextExposer::ViewContext`, but you can subclass this baseclass to add you own logic for more complex scenarios. This also allows for a more modular approach, where you can easily share or subclass logic between different view contexts. Nice!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'context_exposer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install context_exposer
+
+## Usage
+
+Use the `exposed` method which takes a name of the method to be created on the ViewContext and a block with the logic.
+
+Example:
+
+```ruby
+class PostsController < ActionController::Base
+  include ContextExposer::BaseController
+  
+  exposed(:post)  { Post.find params[:id] }
+  exposed(:posts) { Post.find params[:id] }
+end
+```
+
+You can also define your own subclass of `ViewContext` and designate an instance of this custom class as your "exposed" target, via  `view_context_class`method.
+
+Example:
+
+```ruby
+class PostsController < ActionController::Base
+  include ContextExposer::BaseController
+  
+  view_context_class :posts_view_context
+
+  exposed(:post)  { Post.find params[:id] }
+  exposed(:posts) { Post.find params[:id] }
+end
+```
+
+```ruby
+class PostsViewContext < ContextExposer::ViewContext
+  def initialize controller
+    super
+  end
+
+  def total
+    posts.size
+  end
+
+  def admin_posts
+    return [] unless admin?
+    posts.select {|post| post.admin? }
+  end
+
+  protected
+
+  def current_user
+    controller.current_user
+  end
+
+  def admin?
+    current_user.admin?
+  end  
+end
+```
+
+This opens up some amazing possibilities to really put the logic where it belongs.The custom ViewContext would benefit from having the "admin" and "user" logic extracted either to separate modules or a custom ViewContext base class ;)
+
+This approach opens up many new exciting ways to slice and dice your logic in a much better way, a new *MVC-C* architecture, the extra "C" for *Context*.
+
+
+## TODO
+
+Add some useful subclasses of `BaseController`, that add some extra magic!
+Also add some basic modules to integrate with typical authentication solutions etc. Get inspiration from other similar gems, fx `decent_exposure`. Allow for integration between these different solutions.
+
+### ResourceController
+
+It sould be nice to have a `ResourceController` to automatically set up the typical singular and plural-form resource helpers.
+
+This would simplify the above `PostsController` example to this:
+
+```ruby
+class PostsController < ActionController::Base
+  include ContextExposer::ResourceController
+end
+```
+
+Please help out :)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/context_exposer.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'context_exposer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "context_exposer"
+  spec.version       = ContextExposer::VERSION
+  spec.authors       = ["Kristian Mandrup"]
+  spec.email         = ["kmandrup@gmail.com"]
+  spec.description   = %q{Exposes a ViewContext object to the View with all the data needed by the view}
+  spec.summary       = %q{The Context object becomes the single communication point between View and Controller}
+  spec.homepage      = "https://github.com/kristianmandrup/context_exposer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/context_exposer.rb

@@ -0,0 +1,8 @@
+require "context_exposer/version"
+
+module ContextExposer
+end
+
+require "active_support"
+require "context_exposer/base_controller"
+require "context_exposer/view_context"

data/lib/context_exposer/base_controller.rb

@@ -0,0 +1,84 @@
+module ContextExposer::BaseController
+  extend ActiveSupport::Concern
+
+  included do
+    before_filter :configure_exposed_context
+
+    expose_context :context
+  end
+
+  def view_context    
+    @view_context ||= build_view_context
+  end
+  alias_method :context, :view_context
+
+  module ClassMethods
+    def exposed name, &block
+      # puts "store: #{name} in hash storage for class #{self}"
+      exposure_storage[name.to_sym] = block
+    end
+
+    def view_context_class name
+      define_method :view_context_class do
+        @view_context_class ||= name.kind_of?(Class) ? name : name.to_s.camelize.constantize
+      end
+    end
+
+    protected
+
+    def expose_context name
+      return if exposed_view_context?
+      if ActionController::Base.instance_methods.include?(name.to_sym)
+        Kernel.warn "[WARNING] You are exposing the `#{name}` method, " \
+          "which overrides an existing ActionController method of the same name. " \
+          "Consider a different exposure name\n" \
+          "#{caller.first}"
+      end    
+      helper_method name
+      hide_action name
+      @exposed_view_context = true
+    end
+
+    def exposed_view_context?
+      @exposed_view_context ||= false
+    end
+
+    def exposure_storage
+      exposure_hash[self.to_s] ||= {}
+    end
+
+    def exposure_hash
+      @exposure_hash ||= {}
+    end
+  end
+
+  # must be called after Controller is instantiated
+  def configure_exposed_context
+    return if configured_exposed_context?
+    clazz = self.class
+    exposed_methods = clazz.send(:exposure_hash)[clazz.to_s] || []
+    # puts "exposed_methods for: #{clazz} - #{exposed_methods}"
+    exposed_methods.each do |name, procedure|
+      view_context.send :define_singleton_method, name do 
+        procedure.call
+      end
+    end
+    @configured_exposed_context = true
+  end
+
+  def configured_exposed_context?
+    @configured_exposed_context == true
+  end
+
+  protected
+
+  # returns a ViewContext object 
+  # view helpers can be exposed as singleton methods, dynamically be attached (see below)
+  def build_view_context
+    view_context_class.new self
+  end
+
+  def view_context_class
+    @view_context_class ||= ContextExposer::ViewContext
+  end
+end

data/lib/context_exposer/version.rb

@@ -0,0 +1,3 @@
+module ContextExposer
+  VERSION = "0.0.1"
+end

data/lib/context_exposer/view_context.rb

@@ -0,0 +1,14 @@
+class ContextExposer::ViewContext
+  attr_reader :controller
+
+  def initialize controller = nil
+    @controller = controller
+  end
+
+  protected
+
+  def define_singleton_method(name, &block)
+    eigenclass = class<<self; self end
+    eigenclass.class_eval {define_method name, block}
+  end    
+end

data/spec/app/posts_spec.rb

@@ -0,0 +1 @@
+# Run Capybara Spec on Dummy app PostsController

data/spec/context_exposer/expose_spec.rb

@@ -0,0 +1,128 @@
+require 'context_exposer'
+require 'action_controller'
+
+class MyController < ActionController::Base
+  include ContextExposer::BaseController
+  
+  exposed(:post) { Post.find params[:id] }
+
+  def post
+  end
+end
+
+class MyCoolController < ActionController::Base
+  include ContextExposer::BaseController
+  
+  exposed(:coolness) { "MegaCool" }
+
+  view_context_class :mega_cool_view_context
+
+  def show
+    configure_exposed_context
+  end
+
+  def params; end
+end
+
+class MegaCoolViewContext < ContextExposer::ViewContext
+  def initialize controller
+    super
+  end
+
+  def power_of number
+    number * number
+  end
+end
+
+describe ContextExposer::BaseController do
+
+  describe "controller" do
+    subject { controller }
+
+    let(:controller) { MyController.new }
+
+    # run action post
+    before :each do
+      controller.post
+    end
+
+    it 'defines :post as an action_method' do
+      expect(subject.action_methods).to include('post')
+    end
+
+    it "defines a method context" do
+      expect(subject).to respond_to(:context)
+    end
+
+    it "exposes the context to the view layer as a helper" do
+      expect(subject._helper_methods).to include(:context)
+    end
+
+    it "prevents the context method from being routable" do
+      expect(subject.hidden_actions).to include("context")
+    end
+
+    it 'configured exposed context' do
+      expect(subject.configured_exposed_context?).to be_true
+    end
+
+    context 'context' do
+      subject { controller.context }
+
+      it "is an instance of ContextExposer::ViewContext" do
+        expect(subject).to be_a ContextExposer::ViewContext
+      end      
+
+      it "defines a method :bird" do
+        expect(subject).to respond_to(:bird)
+      end      
+
+      it "calling method :bird returns 'Bird' " do
+        expect(subject.bird).to eq "Bird"
+      end      
+    end
+  end
+
+  describe 'MyCoolController' do
+    subject { controller }
+
+    let(:controller) { MyCoolController.new }
+
+    # run action post
+    before :each do
+      controller.show
+    end
+
+    context 'context' do
+      subject { controller.context }
+
+      it "inherits from ContextExposer::ViewContext" do
+        expect(subject).to be_a ContextExposer::ViewContext
+      end      
+
+      it "is an instance of MegaCoolViewContext" do
+        expect(subject).to be_a MegaCoolViewContext
+      end      
+
+      it "has reference to controller" do
+        expect(subject.controller).to eq controller
+      end      
+
+      it "defines a method :coolness" do
+        expect(subject).to respond_to(:coolness)
+      end      
+
+      it "calling method :coolness returns 'MegaCool' " do
+        expect(subject.coolness).to eq "MegaCool"
+      end      
+
+      it "defines a method :power_of" do
+        expect(subject).to respond_to(:power_of)
+      end      
+
+      it "calling method :power_of(2) returns 4" do
+        expect(subject.power_of 2).to eq 4
+      end      
+    end    
+  end
+end