presenter-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5ef5a2774a142651a244f17d207b850cf66d330b
+  data.tar.gz: b5c11f5d72a1f2a6845724ed1d6dbf9b1dea1b08
+SHA512:
+  metadata.gz: 11bf5be25532c008fe7affe61c637ce32a3a24ef5c41149bcc8880e8833d44d96a7cf6ebfd0e6fe7147e87689ea54845d7e38a75f25ff010055dc66090b4d37a
+  data.tar.gz: 1586385a58f932d1adf22d1d97fcc8d18e5ab949d225b193bd2923bd525ee5d09525dd51b3004be2f6a7e2c364e686e9a2b1ca7e20f7202d5ab4cda6a5c9711c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Sam Sargent
+
+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,166 @@
+# presenter-rails
+
+  Presenter is an easy way of implementing the presenter design pattern in Rails.
+
+  With a naming convention based approach, easily define presenter classes to clean up
+  your models and views, handling method delegation based on instance variable & file naming.
+
+  This should hopefully mean you can just use presenter objects in place of model objects
+  throughout your app without effecting any behaviour - as you can still call your custom model
+  methods and active record methods on the presenter objects.
+
+  This ultimately means all methods that belong to the model stay on the model itself
+  and seperated from any methods which don't handle data.
+
+  All presenter classes inherit from ApplicationPresenter generated from the install to keep the same
+  convention you see throughout the rest of your Rails app.
+
+## Installation
+Add this line to your application's Gemfile and bundle:
+```ruby
+gem 'presenter-rails'
+```
+```bash
+$ bundle
+```
+Run the install generator
+```bash
+$ rails g presenter:install
+```
+Add this line to the top of your application.rb
+```ruby
+# config/application.rb
+require 'presenter'
+```
+Followed by this line inside the Application class
+```ruby
+# config/application.rb
+module YourAppName
+  class Application < Rails::Application
+    config.autoload_paths << Rails.root.join('app/presenters')
+  end
+end
+```
+
+## Usage
+
+These instructions will use a 'User' model for example purposes. Just switch out User for your own model names
+
+After you run the install generator, run
+```bash
+$ rails g presenter User
+```
+
+to create a presenter file for one of your models. This will inherit from ApplicationPresenter, example shown below:
+```ruby
+# app/presenters/user_presenter.rb
+class UserPresenter < ApplicationPresenter
+end
+```
+
+Note: This automatically inherits a dynamic initialize method which sets an instance variable. You also inherit a helper method dynamically named after the model too.
+So you DO NOT have to define this yourself:
+```ruby
+def initialize(user)
+  @user = user
+end
+
+def user # Make sure you use the helper methods in your presenters in place of the instance variable.
+  @user
+end
+```
+
+This also comes with with some error handling and some other code. So don't worry about this.
+I'm showing it just so you know what to expect if you try overwrite initialize or the helper without super. If you wish to extend it
+then remember to super or you will overwrite the default behaviour.
+
+If you do wish to extend the initialize method / change the instance variable name, call super first. Next, define an instance variable and assign it to the model object using the helper method (named after the model name).
+```ruby
+def initialize(user)
+  super
+  # assigning your variable to the user method gives it access to the inherited code.
+  @another_variable_name = self.user
+end
+```
+
+This means you can define methods in your presenter using the instance variable named after your model.
+Let's imagine our User model has a first_name and last_name field and we want to define #name. All we would have to do is:
+```ruby
+class UserPresenter < ApplicationPresenter
+  def name
+    "#{user.first_name} #{user.last_name}"
+  end
+end
+```
+
+now you can initialize a presenter. There are 2 methods for this, either directly initialize the object as usual with:
+```ruby
+@user = UserPresenter.new(user)
+```
+or use our built in helper to accomplish the same thing:
+```ruby
+@user = present(user)
+```
+(More on this below)
+
+Example provided shows how it would be used in a controller:
+```ruby
+class UsersController < ApplicationController
+  def show
+    user = User.find(params[:id]) # get an instance of user
+    @user = present(user)
+  end
+end
+```
+
+Now the user instance variable has access to all methods belonging to it's presenter and the model being passed in.
+This allows access to
+```ruby
+@user.name
+# which returns first name and last name like 'Sam Sargent'
+# or even call the normal model methods
+@user.first_name
+# which would delegate the method back to the user model being passed into the present helper
+# returning something like 'Sam'
+# Note: This works with all ActiveRecord methods too, just as if it's an object of the ActiveRecord class User
+#       allowing access to even @user.update(first_name: 'Finn') on the presenter object
+```
+
+## Helper methods
+
+### #present
+
+  #present is a method accessible in controllers and views for initializing new presenter objects
+```ruby
+  user = User.first
+  @user = present(user) # returns a presenter object for that model, replacing need to initialize with #new
+
+  # instead of
+  user = User.first
+  @user = UserPresenter.new(user)
+
+  # alternatively, pass in a collection to return an array of presenter objects
+  users = User.all        # an active record relation
+  @users = present(users)
+  users = User.all.to_a   # an array
+  @users = present(users)
+```
+
+### #instance getter
+
+For each presenter you create, a helper method is defined to get the model object being passed in. This replaces the need to throw around
+the instance variable. It's also faster as it allows the method delegation to not have to parse naming and fetch instance variables every time the inherited #method_missing is called.
+
+shown using a User model as example
+```ruby
+# app/presenters/user_presenter.rb
+class UserPresenter < ApplicationPresenter
+  # this has the method #user defined automatically to access the user object being passed in to the presenter
+  def name
+    "#{user.first_name} {user.last_name}"
+  end
+end
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,23 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Presenter'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+

data/lib/generators/presenter/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Creates a presenter based on a model name for you
+
+Example:
+    rails g presenter user
+
+    This will create:
+        app/presenters/user_presenter.rb

data/lib/generators/presenter/install/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Creates the presenters folder & application_presenter.rb file for you
+
+Example:
+    rails g presenter:install
+
+    This will create:
+        app/presenters
+        app/presenters/application_presenter.rb

data/lib/generators/presenter/install/install_generator.rb

@@ -0,0 +1,12 @@
+module Presenter
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+      class_option :doc, type: :boolean, default: true, desc: 'Include commented documentation'
+
+      def generate_application_presenter
+        template 'application_presenter.template', 'app/presenters/application_presenter.rb'
+      end
+    end
+  end
+end

data/lib/generators/presenter/install/templates/application_presenter.template

@@ -0,0 +1,13 @@
+class ApplicationPresenter < Presenter::Base
+  <%- if options.doc? -%>
+    # You'll notice Presenter::Base, this handles delegation of methods based on naming conventions.
+    # Along with defining the #initialize method & the model helper method for all presenters.
+
+    # Use rails g presenter ModelName to create a presenter file for a model.
+
+    # All presenter classes inherit from this ApplicationPresenter and so define
+    # methods here which you want all your presenters to inherit (just as you usually would).
+
+    # For more, check the docs at: https://www.github.com/samsarge/presenter-rails
+  <%- end -%>
+end

data/lib/generators/presenter/presenter_generator.rb

@@ -0,0 +1,11 @@
+module Presenter
+  class PresenterGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    class_option :doc, type: :boolean, default: true, desc: 'Include commented documentation'
+    argument :model, type: :string
+
+    def generate_model_presenter
+      template 'model_presenter.template', "app/presenters/#{model.singularize.underscore}_presenter.rb"
+    end
+  end
+end

data/lib/generators/presenter/templates/model_presenter.template

@@ -0,0 +1,12 @@
+class <%= "#{model.singularize.camelcase}Presenter" %> < ApplicationPresenter
+  <%- if options.doc? -%>
+    # Don't worry about the initialize method, it's already handled for you.
+
+    # You can now pass in an instance of <%= model.singularize.camelcase %> when you initialize this presenter
+    # and access it with the helper method
+    # #<%= model.singularize.underscore %>
+    # instead of an instance variable when writing your methods
+
+    # Write methods for this presenter in here using the helper method
+  <%- end -%>
+end

data/lib/presenter.rb

@@ -0,0 +1,5 @@
+require 'presenter/naming'
+require 'presenter/base'
+require 'presenter/helper'
+require 'presenter/controller'
+require 'presenter/version'

data/lib/presenter/base.rb

@@ -0,0 +1,25 @@
+module Presenter
+  class Base
+    include Presenter::Naming
+
+    def initialize(model)
+      @model = model
+      generate_model_instance_getter
+    end
+
+    protected
+    def generate_model_instance_getter
+      define_singleton_method model_object_name_from_presenter(@model) do
+        @model
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      @model.send(method, *args, &block)
+    end
+
+    def respond_to_missing?(method, include_all = false)
+      @model.respond_to?(method, include_all)
+    end
+  end
+end

data/lib/presenter/controller.rb

@@ -0,0 +1,3 @@
+ActionController::Base.class_eval do
+  include Presenter::Helper
+end

data/lib/presenter/helper.rb

@@ -0,0 +1,12 @@
+module Presenter
+  module Helper
+    include Presenter::Naming
+    def present(object_or_collection)
+      if object_or_collection.respond_to?(:map) # If it is a collection
+        object_or_collection.map { |object| presenter_from_model_object(object).new(object) }
+      else # If it is a single object
+        presenter_from_model_object(object_or_collection).new(object_or_collection)
+      end
+    end
+  end
+end

data/lib/presenter/naming.rb

@@ -0,0 +1,17 @@
+# This module is for naming related methods
+module Presenter
+  module Naming
+    def model_object_name_from_presenter(model)
+      model.class.to_s.underscore.sub('_presenter', '')
+    end
+
+    def presenter_from_model_object(model)
+      presenter_name(model).constantize
+    end
+
+    private
+    def presenter_name(model)
+      "#{model.class.to_s}Presenter"
+    end
+  end
+end

data/lib/presenter/version.rb

@@ -0,0 +1,3 @@
+module Presenter
+  VERSION = '0.1.0'
+end

data/lib/tasks/presenter/rails_tasks.rake

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

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: presenter-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sam Sargent
+- Finn Francis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.2
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Keep code neat and abstract view & presenter logic. Adding a simple separation
+  of concerns when creating your models with an easy API.
+email:
+- samsarge@hotmail.co.uk
+- finnfrancis123@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/generators/presenter/USAGE
+- lib/generators/presenter/install/USAGE
+- lib/generators/presenter/install/install_generator.rb
+- lib/generators/presenter/install/templates/application_presenter.template
+- lib/generators/presenter/presenter_generator.rb
+- lib/generators/presenter/templates/model_presenter.template
+- lib/presenter.rb
+- lib/presenter/base.rb
+- lib/presenter/controller.rb
+- lib/presenter/helper.rb
+- lib/presenter/naming.rb
+- lib/presenter/version.rb
+- lib/tasks/presenter/rails_tasks.rake
+homepage: https://github.com/samsarge/presenter-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Easily implement the presenter design pattern in rails projects.
+test_files: []