basic_presenter 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+.bundle
+Gemfile.lock
+pkg

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-f d

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'activesupport'
+gem 'rspec'

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2014 vinsol.com
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Spree nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,244 @@
+[![Code Climate](https://codeclimate.com/github/vinsol/basic_presenter.png)](https://codeclimate.com/github/vinsol/basic_presenter)
+
+# BasicPresenter
+# 
+
+
+
+BasicPresenter adds a layer of presentation logic to your application.
+
+Its inspired from https://github.com/railscasts/287-presenters-from-scratch/ and
+http://svs.io/day/2012/12/27
+
+## Inspiration
+
+Rails being a flexible framework starts with all methods being part of model and
+when it gets big, developers are haunted with the daunting task of its maintenance.
+
+Leveraging Presentation pattern with Presenters requires lot of context loading with
+separating view/derived methods from actual objects and moving them to presenters and making
+relevant changes to instantiate right object wherever needed.
+
+By letting the knowledge of Presenters slip through model leveraging delegation helps us with
+the movement of view/derived methods from actual objects to presenters without letting other
+code to know about the delegation and change. Strict movement and no other code change.
+
+## Why use Presenters?
+
+Presenters deal with presentation, so your models can concentrate on
+domain logic. Instead of polluting models with presenter logic, you can implement the
+presenter method in a presenter instead.
+
+## Installation
+
+Requires active_support
+
+Add this line to your application's Gemfile:
+
+    gem 'basic_presenter'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install basic_presenter
+
+Or to use the edge version, add this to your Gemfile:
+
+    gem 'basic_presenter', :github => 'vinsol/basic_presenter'
+
+## Usage
+
+
+#### Creating Presenter Directory
+
+```sh
+rails g basic_presenter:install
+```
+
+#### Generating Presenters
+
+To generate a presenter by itself:
+
+```sh
+rails g basic_presenter:presenter User
+```
+
+### Writing Presenters
+
+Presenters are stored in `app/presenters`, they inherit from
+`BasicPresenter::BasePresenter` and are named based on the model they
+present. We also recommend you create an `ApplicationPresenter`.
+
+### Accessing the Model
+
+You can access the model using the `domain_object` method, or the model name (in this case `user`). For example:
+
+
+```ruby
+# app/models/user.rb
+class User
+  attr_accessor :first_name, :last_name
+
+  def initialize(first_name, last_name)
+    @first_name = first_name
+    @last_name = last_name
+  end 
+end
+
+# app/presenters/application_presenter.rb
+class ApplicationPresenter < BasicPresenter::BasePresenter 
+end
+  
+
+# app/presenters/user_presenter.rb
+class UserPresenter < ApplicationPresenter
+  # You can access the model using the `domain_object` method,
+  # or the model name (in this case `user`). For example:
+
+  presents :user
+
+  @delegation_methods = [:first_name, :last_name]
+
+  # Use ActiveSupport `delegate`
+  delegate *@delegation_methods, to: :user
+
+  def full_name
+    first_name + last_name
+  end
+end
+```
+
+The model name is either inferred from the model class name - taking
+`User` and adding `Presenter` to it.  
+`presents` creates a wrapper for domain model object to call it close to
+domain than something like `domain_object`
+
+
+### Wrapping Models with Presenters
+
+#### Just pass the model to a new presenter instance:
+
+```ruby
+user = User.new('Vinsol', 'User')
+user_presenter = UserPresenter.new(user)
+user_presenter.full_name # Output: VinsolUser
+```
+
+#### Use model `#presenter` method
+
+```ruby
+# app/models/user.rb
+class User
+  include BasicPresenter::Concern
+
+  attr_accessor :first_name, :last_name
+
+  def initialize(first_name, last_name)
+    @first_name = first_name
+    @last_name = last_name
+  end
+end
+
+user = User.new('Vinsol', 'User')
+user.presenter.full_name # Output: VinsolUser
+```
+
+#### Override default_presenter class `UserPresenter` for User, you can set `AdminPresenter`
+
+```ruby
+# app/presenters/admin_presenter.rb
+class AdminPresenter < ApplicationPresenter
+  # You can access the model using the `domain_object` method,
+  # or the model name (in this case `admin`). For example:
+
+  presents :admin
+
+  @delegation_methods = [:first_name, :last_name]
+
+  # Use ActiveSupport `delegate`
+  delegate *@delegation_methods, to: :admin
+
+  def full_name
+    "#{first_name}-#{last_name}"
+  end
+end
+
+user = User.new('Vinsol', 'User')
+user.presenter.full_name # Output: VinsolUser
+user.presenter_class = AdminPresenter
+user.presenter.full_name # Output: Vinsol-User
+```
+
+#### Enhancing `User` to allow calls like `user.presenter.full_name` to be `user.full_name`
+
+```ruby
+# app/models/user.rb
+class User
+  include BasicPresenter::Concern
+
+  attr_accessor :first_name, :last_name
+
+  @delegation_methods = [:full_name]
+
+  # Use ActiveSupport `delegate`
+  # No change in this line needed
+  # As BasicPresenter::Concern Module always exposes presenter method
+  # to return presenter instance
+
+  delegate *@delegation_methods, to: :presenter
+
+  def initialize(first_name, last_name)
+    @first_name = first_name
+    @last_name = last_name
+  end
+end
+
+user = User.new('Vinsol', 'User')
+user.presenter.full_name # Output: VinsolUser
+user.full_name # Output: VinsolUser
+user.presenter_class = AdminPresenter
+user.presenter.full_name # Output: Vinsol-User
+user.full_name # Output: Vinsol-User
+```
+
+
+### Testing
+
+#### RSpec
+
+**PENDING:** The specs are placed in `spec/presenters`. Add `type: :presenter` if they are placed elsewhere.
+
+## Acknowledgements
+
+- https://github.com/railscasts/287-presenters-from-scratch/
+- http://svs.io/day/2012/12/27
+
+## License
+
+Mozilla Public License Version 2.0
+
+Free to use in open source or proprietary applications, with the
+caveat that any source code changes or additions to files covered
+under MPL V2 can only be distributed under the MPL V2 or secondary
+license as described in the full text.
+
+## 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
+
+## Credits
+
+[![vinsol.com: Ruby on Rails, iOS and Android
+developers](http://vinsol.com/vin_logo.png "Ruby on Rails, iOS and
+Android developers")](http://vinsol.com)
+
+Copyright (c) 2014 [vinsol.com](http://vinsol.com "Ruby on Rails, iOS
+and Android developers"), released under the New MIT License
+

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => [:spec]

data/basic_presenter.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name        = "basic_presenter"
+  s.version     = '0.0.2'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Pikender Sharma", "Hemant Khemani", "Akhil Bansal"]
+  s.email       = "info@vinsol.com"
+  s.homepage    = "http://vinsol.com"
+  s.summary     = "Introduce presenters to your rails app"
+  s.description = "A simplified way to glue presenter methods to its domain object"
+
+  s.license = 'MIT'
+
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  #s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  #s.extra_rdoc_files = [ 'README.md' ]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = "lib"
+  s.add_dependency 'activesupport', '>= 3.0'
+end

data/lib/basic_presenter/base_presenter.rb

@@ -0,0 +1,23 @@
+require 'active_support/core_ext/module/delegation.rb'
+
+module BasicPresenter
+  class BasePresenter
+    # extend Forwardable
+    # Presenter Class should allow DomainClass instance 
+    # to be initialized
+
+    attr_reader :domain_object
+
+    def initialize(domain_object)
+      @domain_object = domain_object
+    end
+
+    class << self
+      def presents(name)
+        define_method(name) do
+          @domain_object
+        end
+      end
+    end
+  end
+end

data/lib/basic_presenter/concern.rb

@@ -0,0 +1,37 @@
+require 'active_support/inflector'
+
+module BasicPresenter
+  module Concern
+    def presenter
+      if @presenter_class.nil?
+        @old_presenter_class = self.presenter_class = presenter_class
+        return @presenter = presenter_class.new(self)
+      end
+      return @presenter if presenter_class_not_changed?
+      @presenter = presenter_class.new(self)
+      @old_presenter_class = @presenter_class
+      @presenter
+    end
+
+    def default_presenter
+      "#{self.class}Presenter".constantize
+    end
+
+    def presenter_class
+      @presenter_class || default_presenter
+    end
+
+    def presenter_class=(vd)
+      @old_presenter_class = @presenter_class
+      @presenter_class = vd
+    end
+
+    def presenter_class_changed?
+      !(presenter_class_not_changed?)
+    end
+
+    def presenter_class_not_changed?
+      (@old_presenter_class == @presenter_class)
+    end
+  end
+end

data/lib/basic_presenter.rb

@@ -0,0 +1,5 @@
+require 'basic_presenter/concern'
+require 'basic_presenter/base_presenter'
+
+module BasicPresenter
+end

data/lib/generators/basic_presenter/install_generator.rb

@@ -0,0 +1,17 @@
+module BasicPresenter
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      def create_presenters_dir
+        empty_directory('app/presenters')
+      end
+
+      def create_presenter_file
+        create_file "app/presenters/application_presenter.rb", <<-FILE
+  class ApplicationPresenter < BasicPresenter::BasePresenter
+    ## Shared Methods might come here
+  end
+        FILE
+      end
+    end
+  end
+end

data/lib/generators/basic_presenter/presenter_generator.rb

@@ -0,0 +1,26 @@
+module BasicPresenter
+  module Generators
+    class PresenterGenerator < Rails::Generators::NamedBase
+
+      check_class_collision suffix: "Presenter"
+
+      def create_presenter_file
+        create_file "app/presenters/#{file_name}_presenter.rb", <<-FILE
+  class #{class_name}Presenter < ApplicationPresenter
+    presents :#{plural_name.singularize}
+
+    # Methods delegated to Presented Class #{class_name} object's #{plural_name.singularize}
+    @delegation_methods = []
+
+    delegate *@delegation_methods, to: :#{plural_name.singularize}
+
+    # Start the methods
+    # def full_name
+    #   first_name + last_name
+    # end
+  end
+        FILE
+      end
+    end
+  end
+end

data/spec/basic_presenter/concern_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+#require 'forwardable'
+
+class DomainClass
+  include BasicPresenter::Concern
+
+  attr_accessor :first_name, :last_name
+
+  def initialize(first_name, last_name)
+    @first_name = first_name
+    @last_name = last_name
+  end
+end
+
+#class BasePresenter
+#  # extend Forwardable
+#  # Presenter Class should allow DomainClass instance 
+#  # to be initialized
+#
+#  attr_reader :domain_object
+#
+#  def initialize(domain_object)
+#    @domain_object = domain_object
+#  end
+#
+#  class << self
+#    def presents(name)
+#      define_method(name) do
+#        @domain_object
+#      end
+#    end
+#  end
+#end
+
+class DomainClassPresenter < BasicPresenter::BasePresenter
+  presents :domain_class
+
+  @delegation_methods = [:first_name, :last_name]
+
+  # def_delegators :domain_class, *@delegation_methods
+  delegate *@delegation_methods, to: :domain_class
+
+  def full_name
+    first_name + last_name
+  end
+end
+
+class AnotherPresenter < BasicPresenter::BasePresenter
+  presents :domain_class
+
+  def full_name
+    domain_class.first_name + domain_class.last_name
+  end
+end
+
+module BasicPresenter
+  describe Concern do
+    let(:dummy_domain_object) { DomainClass.new('Welcome', 'Presenter') }
+
+    context "Presenter Class Modification Interface" do
+      it "should determine default presenter class by the Domain Class" do
+        dummy_domain_object.default_presenter.should eq(DomainClassPresenter)
+      end
+
+      it "should tell current presenter class" do
+        dummy_domain_object.presenter_class.should eq(DomainClassPresenter)
+      end
+
+      it "should assume default presenter class as presenter class when not set" do
+        dummy_domain_object.presenter_class.should eq(DomainClassPresenter)
+      end
+
+      it "should recognize presenter class when set" do
+        dummy_domain_object.presenter_class.should eq(DomainClassPresenter)
+        dummy_domain_object.presenter_class = AnotherPresenter
+        dummy_domain_object.presenter_class.should eq(AnotherPresenter)
+      end
+    end
+
+    context "Helper Methods" do
+      it "should be able to inform change in Presenter Class" do
+        dummy_domain_object.presenter_class.should eq(DomainClassPresenter)
+        dummy_domain_object.should be_presenter_class_not_changed
+        dummy_domain_object.presenter_class = AnotherPresenter
+        dummy_domain_object.should be_presenter_class_changed
+        dummy_domain_object.presenter_class.should eq(AnotherPresenter)
+      end
+    end
+
+    context "Presenter Instance Creation to allow delegation of Presenter Methods" do
+      it "should delegate presenter methods on Default Presenter when not set" do
+        dummy_domain_object.presenter.should be_an_instance_of(DomainClassPresenter)
+      end
+
+      it "should delegate presenter methods on Explicit Presenter if set" do
+        dummy_domain_object.presenter_class = AnotherPresenter
+        dummy_domain_object.presenter.should be_an_instance_of(AnotherPresenter)
+      end
+
+      context "Create Presenter Instance Once and return same if Presenter Class not changed" do
+        it "when no Presenter Class set" do
+          dummy_domain_object_presenter = dummy_domain_object.presenter
+          dummy_domain_object.presenter.should eq(dummy_domain_object_presenter)
+          dummy_domain_object.presenter.should eq(dummy_domain_object_presenter)
+          dummy_domain_object.presenter.should eq(dummy_domain_object_presenter)
+        end
+
+        it "when Presenter Class changed" do
+          dummy_domain_object_presenter = dummy_domain_object.presenter
+          dummy_domain_object.presenter_class = AnotherPresenter
+          new_dummy_domain_object_presenter = dummy_domain_object.presenter
+          dummy_domain_object_presenter.should be_an_instance_of(DomainClassPresenter)
+          new_dummy_domain_object_presenter.should be_an_instance_of(AnotherPresenter)
+          dummy_domain_object.presenter.should eq(new_dummy_domain_object_presenter)
+          dummy_domain_object.presenter.should eq(new_dummy_domain_object_presenter)
+          dummy_domain_object.presenter.should eq(new_dummy_domain_object_presenter)
+        end
+      end
+    end
+
+    describe "Presenter Methods Available on Domain Object through #presenter" do
+      it "should allow presenter methods to be called through #presenter" do
+        dummy_domain_object.presenter.full_name.should eq('WelcomePresenter')
+      end
+
+      it "should allow domain_object to be accessed through #domain_object" do
+        dummy_domain_object.presenter.domain_object.should eq(dummy_domain_object)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'basic_presenter'

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: basic_presenter
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Pikender Sharma
+- Hemant Khemani
+- Akhil Bansal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A simplified way to glue presenter methods to its domain object
+email: info@vinsol.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- basic_presenter.gemspec
+- lib/basic_presenter.rb
+- lib/basic_presenter/base_presenter.rb
+- lib/basic_presenter/concern.rb
+- lib/generators/basic_presenter/install_generator.rb
+- lib/generators/basic_presenter/presenter_generator.rb
+- spec/basic_presenter/concern_spec.rb
+- spec/spec_helper.rb
+homepage: http://vinsol.com
+licenses:
+- MIT
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Introduce presenters to your rails app
+test_files: []