delegated_presenter 0.1.1 → 1.0.0

data/.gitignore

@@ -2,6 +2,13 @@
 *.rbc
 .bundle
 .config
+.idea
+log/*.log
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache
 .yardoc
 Gemfile.lock
 InstalledFiles

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - 1.9.1
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -1,4 +1,17 @@
-source 'https://rubygems.org'
+source "http://rubygems.org"
 
-# Specify your gem's dependencies in delegated_presenter.gemspec
+# Declare your gem's dependencies in delegated_presenter.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
 gemspec
+
+# jquery-rails is used by the dummy application
+gem "jquery-rails"
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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

@@ -1,6 +1,6 @@
 # DelegatedPresenter
 
-TODO: Write a gem description
+DelegatedPresenter gives you an easy way to present objects and collections to your models. It uses ruby's Delegate model so it is lightweight and functional!
 
 ## Installation
 
@@ -18,7 +18,74 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Generate a presenter using a rails generator:
+
+    $ rails g delegated_presenter contact
+
+### Add some functionality to your presenter
+
+```ruby
+class ContactPresenter < DelegatedPresenter::Base
+
+  # By default this presenter will try and present a Contact if it exists.
+  # You can explicitly tell the presenter to present other models using the following syntax:
+
+  presents OtherContact, SomeOtherModel
+
+  # Add some functionality to your presenter!
+  # The presenter will always look to the model it is presenting for methods and attributes not defined in the presenter.
+  # If you want to override model method, you can always call `presented_model.{method_name}` to access the original method.
+
+  def middle_initial
+    "#{middle_name.first}." if middle_name
+  end
+
+  def full_name
+    [prefix, first_name, middle_initial, last_name, suffix].compact.join(' ')
+  end
+
+end
+```
+
+### Use the controller helper
+See: {DelegatedPresenter::PresentsBeforeRendering}
+
+Use the following to present a model instance or collection with a presenter, by default it will try and use a presenter with the same class as the instance or collection.
+
+```ruby
+class ContactsController < ApplicationController
+
+  presents :contact
+
+end
+```
+
+If you for any reason need to explicitly define the presenter you may define a ```with: :presenter_name``` option, like so.
+
+```ruby
+class UsersController < ApplicationController
+
+  presents :user, with: :contact_presenter
+
+end
+```
+
+Or if you like you can just manually initialize the presenter in your actions.
+
+```ruby
+class ContactsController < ApplicationController
+
+  def index
+    @contacts = ContactPresenter.new Contact.all
+  end
+
+  def show
+    @contact = ContactPresenter.new Contact.find(params[:id])
+  end
+
+end
+
+```
 
 ## Contributing
 

data/README.rdoc

@@ -0,0 +1,3 @@
+= DelegatedPresenter
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -1 +1,27 @@
-require "bundler/gem_tasks"
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DelegatedPresenter'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/delegated_presenter.gemspec

@@ -17,4 +17,12 @@ Gem::Specification.new do |gem|
   gem.test_files      = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths   = ["lib"]
   gem.add_dependency  "activesupport"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "rspec-rails"
+  gem.add_development_dependency "rails"
+  gem.add_development_dependency "factory_girl"
+  gem.add_development_dependency "database_cleaner"
+
 end

data/lib/delegated_presenter/base.rb

@@ -1,34 +1,146 @@
+# @abstract Inherit from it to create a presenter.
+# @raise [DelegatedPresenter::Error::MethodHidden]
+#    If a method is specified as hidden.
+# @raise [DelegatedPresenter::Error::MethodNotExposed]
+#    If a method is not exposed.
 class DelegatedPresenter::Base < SimpleDelegator
 
-  @@presentable = {}
+  PRESENTABLE = {}
+  HIDDEN_METHODS = {}
+  EXPOSED_METHODS = {}
+
+  private_constant :PRESENTABLE, :HIDDEN_METHODS, :EXPOSED_METHODS
+
+  delegate :exposed_methods, :hidden_methods, :presentable_objects, to: :presenter_class
 
   alias :presented_model :__getobj__
 
+  # Initializes the presenter with an object.
+  # @param object Can be an collection or instance of a presentable models.
+  # @raise [DelegatedPresenter::Error::NotPresentable] if the object is not instance or collection
+  #   of a presentable model.
   def initialize(object)
-    raise Presenter::NotPresentable, "#{self.presenter_class} cannot present a #{object.class}" unless self.presentable.include?(object.class.name)
-    super(object)
-    freeze
+    if object.is_a?(Array)
+      map_array(object)
+    else
+      raise DelegatedPresenter::Error::NotPresentable, "#{self.presenter_class} cannot present a #{object.class}" unless object_is_presentable?(object)
+      __setobj__(object)
+      if exposed_methods
+        expose_methods
+      elsif hidden_methods
+        hide_methods
+      end
+    end
   end
 
+  # The class of the presenter.
   alias_method :presenter_class, :class
 
+  # The class of the presented object.
   def class
-    __getobj__.class
+    presented_model.class
   end
 
-  def presentable
-    (@@presentable[self.presenter_class.name] || [])
-  end
+  private
 
+  # Determine what objects what to present.
+  # @!visibility public
+  # @param :objects One or more models to be presented.
+  # @example Add some presentable objects:
+  #     presents :contact, :user, :client
   def self.presents(*objects)
-    @@presentable[name] ||= []
-    @@presentable[name] += objects.flatten.collect{ |i| i.to_s.camelize.singularize }
+    PRESENTABLE[name] ||= []
+    PRESENTABLE[name] += objects.flatten.collect{ |i| i.to_s.camelize.singularize }
+  end
+
+  # @!visibility public
+  # Hide methods from the presenter.
+  # @param methods one ore more methods from the model to hide from the presenter.
+  # @example Hide methods:
+  #     hide :id, :crypted_password, :password_salt
+  def self.hide(*hidden_methods)
+    self.hidden_methods[name] ||= []
+    self.hidden_methods[name] += hidden_methods
+  end
+
+  # @!visibility public
+  # Exposes methods to the presenter, when defined all others will be hidden.
+  # @param :methods one ore more methods from the model to expose from the presenter.
+  # @example Expose methods:
+  #     expose :first_name, :last_name
+  def self.expose(*exposed_methods)
+    EXPOSED_METHODS[name] ||= []
+    EXPOSED_METHODS[name] += exposed_methods.flatten
   end
 
+  ## Internal Methods: Not Documented
+
+  # @api private
   def self.inherited(subclass)
     presentable_class = subclass.name.gsub(/Presenter$/,'')
     presentable_class.constantize rescue nil
     subclass.presents presentable_class if Object.const_defined?(presentable_class)
   end
 
+  ## Inherited Object Getters
+
+  # Presentable Objects
+  # @api private
+  def self.presentable_objects
+    (PRESENTABLE[name] || [])
+  end
+
+  # Methods to expose
+  # @api private
+  def self.exposed_methods
+    EXPOSED_METHODS[name]
+  end
+
+  # Methods to hide
+  # @api private
+  def self.hidden_methods
+    HIDDEN_METHODS[name]
+  end
+
+  # Raises an error when hidden methods are called.
+  # @api private
+  def hide_methods
+    hidden_methods.flatten.each do |i|
+      singleton_class.send :define_method, i do |*args|
+        raise DelegatedPresenter::Error::MethodHidden, "Method `#{i} is hidden."
+      end
+    end
+  end
+
+  # Hides all methods except the ones exposed
+  # @api private
+  def expose_methods
+    (unique_model_methods - exposed_methods).flatten.each do |i|
+      singleton_class.send :define_method, i do |*args|
+        raise DelegatedPresenter::Error::MethodNotExposed, "Method `#{i} is not exposed."
+      end
+    end
+  end
+
+  # Determines if an object is presentable
+  # @api private
+  def object_is_presentable?(object)
+    presentable_objects.include?(object.class.name)
+  end
+
+  # Extracts the the models unique methods from the superclass
+  # @api private
+  def unique_model_methods
+    presented_model.methods - presented_model.class.superclass.instance_methods
+  end
+
+  # Maps an array of instances to delegated presented instances
+  # @api private
+  def map_array(array)
+    array.map!{ |object| presenter_class.new(object) }
+    inherited_methods = presenter_class.instance_methods - DelegatedPresenter::Base.instance_methods
+    inherited_methods.each { |i| singleton_class.send(:undef_method, i) }
+    __setobj__ array
+  end
+
 end

data/lib/delegated_presenter/error.rb

@@ -1,4 +1,15 @@
 module DelegatedPresenter::Error
+
+  # Error raised when an object is not presentable.
   class NotPresentable < StandardError
   end
+
+  # Error raised when a method is not exposed.
+  class MethodNotExposed < StandardError
+  end
+
+  # Error raised when a method is not exposed.
+  class MethodHidden < StandardError
+  end
+
 end

data/lib/delegated_presenter/presents_before_rendering.rb

@@ -0,0 +1,46 @@
+module DelegatedPresenter::PresentsBeforeRendering
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :presents_before_rendering
+    self.presents_before_rendering = []
+  end
+
+  private
+
+  # Presents specified instance variables before rendering.
+  def render
+    presents_before_rendering.each do |var|
+      ivar = instance_variable_get("@#{var}")
+      if ivar.present?
+        object_class = [ivar].flatten.collect(&:class).first.to_s
+        instance_variable_set("@#{var}", (object_class + 'Presenter').constantize.new(ivar))
+      end
+    end
+
+    super
+  end
+
+  module ClassMethods
+
+    private
+
+    # @!visibility public
+    # Sets up a presenter for instance variables. By default it will try to determine the presenter but this can be overridden via the "*with*" option.
+    # @overload presents(instance_var1, instance_var2, [...])
+    #     Specifies which instance variables to present, assumes the presenter has a name of *InstanceClassPresenter*.
+    #     @param instance_vars the instance variables to present.
+    # @overload presents(instance_var1, instance_var2, [...], options)
+    #     Specifies which instance variables to present, assumes the presenter has a name of *InstanceClassPresenter*.
+    #     @param instance_vars the instance variables to present.
+    #     @option options [Symbol] :with The presenter to use.
+    def presents(*instance_vars)
+      options = instance_vars.extract_options!
+      self.presents_before_rendering += instance_vars.flatten.map(&:to_s)
+    end
+
+    alias :present :presents
+
+  end
+
+end

data/lib/delegated_presenter/railtie.rb

@@ -4,4 +4,10 @@ class DelegatedPresenter::Railtie < Rails::Railtie
     require "generators/delegated_presenter_generator"
   end
 
+  initializer "Add presents before rendering to controller" do
+    ActiveSupport.on_load :action_controller do
+      ActionController::Base.send :include, DelegatedPresenter::PresentsBeforeRendering
+    end
+  end
+
 end

data/lib/delegated_presenter/version.rb

@@ -1,3 +1,3 @@
 module DelegatedPresenter
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/lib/delegated_presenter.rb

@@ -5,6 +5,8 @@ module DelegatedPresenter
 
   autoload :Base
   autoload :Error
+  autoload :PresentsBeforeRendering
+
 end
 
 require 'delegated_presenter/railtie' if defined?(Rails)

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

@@ -1,6 +1,6 @@
 class <%= class_name %>Presenter < DelegatedPresenter::Base
 
-  # By default this presenter wil try and present a `<%= class_name %>` if it exists.
+  # By default this presenter will try and present a `<%= class_name %>` if it exists.
   # You can explicitly tell the presenter to present other models using the following syntax:
 
   # presents MyModel1, MyModel2

data/lib/tasks/delegated_presenter_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :delegated_presenter do
+#   # Task goes here
+# end

data/spec/dummy/.rspec

@@ -0,0 +1 @@
+--color