resourcerer 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fca34cdbd0b9675cd1e3dc66a1e664acca9c3c45
+  data.tar.gz: 64565620b02df20d0988d258973f3cc1e843c7eb
+SHA512:
+  metadata.gz: 2f6bc395bf6917acfb7030d6275ab4f77d559d0a5c7bda6ac8ece7b9618fce610137f06e6c1dd17f440b42f0c1669bc548d4f9dd2489bd0d67e144d7f522d0f5
+  data.tar.gz: bb1d46a0030aa19625c4391511af787d4eab12a95161f946fc5c4c84ddbe0ef75c934cec8723fb5e77dac14532f7bbbf8af567718c65d15f54d8e86b07e63823

data/README.md

@@ -0,0 +1,258 @@
+Resourcerer
+=====================
+What `resourcerer` proposes is that you go from this:
+
+```ruby
+class Controller
+  def new
+    @person = Person.new
+  end
+
+  def create
+    @person = Person.new(person_params)
+    if @person.save
+      redirect_to(@person)
+    else
+      render :new
+    end
+  end
+
+  def edit
+    @person = Person.find(params[:id])
+  end
+
+  def update
+    @person = Person.find(params[:id])
+    if @person.update_attributes(person_params)
+      redirect_to(@person)
+    else
+      render :edit
+    end
+  end
+  
+  private
+    def person_params
+      params.require(:person).permit(:name)
+    end
+end
+```
+
+To something like this:
+
+```ruby
+class Controller
+  resource :person
+
+  def create
+    if person.save
+      redirect_to(person)
+    else
+      render :new
+    end
+  end
+
+  def update
+    if person.save
+      redirect_to(person)
+    else
+      render :edit
+    end
+  end
+  
+  private
+    def person_params
+      params.require(:person).permit(:name)
+    end
+end
+```
+
+The idea is that you don't have to write boilerplate for standard CRUD actions, while at the same time improving your controllers readibility.
+
+## Usage
+
+Let's see what Resourcerer is doing behind the curtains :smiley:. This examples assume that you are using Rails 4 Strong Parameters.
+
+### Obtaining a resource:
+
+```ruby
+resource :person
+```
+
+**Query Explanation**
+
+<table>
+  <tr>
+    <td><code>id</code> present?</td>
+    <td>Query (get/delete)</td>
+    <td>Query (post/patch/put)</td>
+  </tr>
+  <tr>
+    <td><code>true</code></td>
+    <td><code>Person.find(params[:id])</code></td>
+    <td><code>Person.find(params[:id]).attributes = person_params</code></td>
+  </tr>
+  <tr>
+    <td><code>false</code></td>
+    <td><code>Person.new</code></td>
+    <td><code>Person.new(person_params)</code></td>
+  </tr>
+</table>
+
+
+### Configuration
+
+Let's take a look at some of the things you can do:
+
+**Specify the model name:**
+
+```ruby
+resource(:company, model: :enterprise)
+```
+
+**Specify the parameter key to use to fetch the object:**
+
+```ruby
+resource(:enterprise, finder_param: :company_id)
+```
+
+**Specify how to obtain the object attributes:**
+
+```ruby
+# Specify the strong parameters method's name when using the default `StrongParametersStrategy`
+resource(:employee, attributes_method: :person_params)
+
+# Specify the parameter key that holds the attributes when using the `EagerAttributesStrategy`
+resource(:person, param_key: :employee)
+```
+
+### Setting a distinct object for a single action
+
+There are times when one action in a controller is different from the
+rest of the actions. A nice approach to circumvent this is to use the
+controller's setter methods. This example uses [presenter_rails](https://github.com/ElMassimo/presenter_rails).
+
+```ruby
+resource(:article)
+
+def show_oldest
+  self.article = Article.find_oldest
+end
+
+present :article do
+  ArticlePresenter.new(article)
+end
+```
+
+### Custom strategies
+
+For times when you need custom behavior for resource finding, you can
+create your own strategy by extending `Resourcerer::Strategy`:
+
+```ruby
+class VerifiableStrategy < Resourcerer::Strategy
+  delegate :current_user, :to => :controller
+
+  def resource
+    instance = model.find(params[:id])
+    if current_user != instance.user
+      raise ActiveRecord::RecordNotFound
+    end
+    instance
+  end
+end
+```
+
+You would then use your custom strategy in your controller:
+
+```ruby
+resource(:post, strategy: VerifiableStrategy)
+```
+
+## Using decorators or presenters
+### With [draper](http://github.com/drapergem/draper)
+
+If you use decorators, you can go from something like this:
+
+```ruby
+class Controller
+  def new
+    @person = Person.new.decorate
+  end
+
+  def create
+    @person = Person.new(person_params)
+    if @person.save
+      redirect_to(@person)
+    else
+      @person = @person.decorate
+      render :new
+    end
+  end
+
+  def edit
+    @person = Person.find(params[:id]).decorate
+  end
+
+  def update
+    @person = Person.find(params[:id])
+    if @person.update_attributes(person_params)
+      redirect_to(@person)
+    else
+      @person = @person.decorate
+      render :edit
+    end
+  end
+  
+  private
+    def person_params
+      params.require(:person).permit(:name)
+    end
+end
+```
+
+To something like this by adding [presenter_rails](https://github.com/ElMassimo/presenter_rails) to the mix:
+
+```ruby
+class Controller
+  resource(:person)
+  
+  present :person do
+    person.decorate
+  end
+
+  def create
+    if person.save
+      redirect_to(person)
+    else
+      render :new
+    end
+  end
+
+  def update
+    if person.save
+      redirect_to(person)
+    else
+      render :edit
+    end
+  end
+
+  private
+    def person_params
+      params.require(:person).permit(:name)
+    end
+end
+```
+
+### Comparison with [decent_exposure](https://github.com/voxdolo/decent_exposure).
+
+Resourcerer is heavily inspired on [decent exposure](https://github.com/voxdolo/decent_exposure), it attempts to be more predictable by focusing on finding a resource and assigning attributes, and discarding completely the view exposure part.
+
+#### Similarities
+Both allow you to find or initialize a resource and assign attributes, removing the boilerplate from most CRUD actions.
+
+#### Differences
+Resourcerer does not expose an object to the view in any way, scope the query to a collection method if defined, nor deal with collections.
+
+
+### Special Thanks
+Resourcerer was inspired by [decent_exposure](https://github.com/voxdolo/decent_exposure).

data/lib/resourcerer/inflector.rb

@@ -0,0 +1,33 @@
+require 'active_support/inflector'
+require 'active_support/core_ext/string'
+require 'active_model/naming'
+
+module Resourcerer
+  class Inflector
+    attr_reader :original, :model, :finder_attribute
+
+    def initialize(name, model, finder_attribute=:id)
+      @original, @model, @finder_attribute = name.to_s, model, finder_attribute
+    end
+
+    alias name original
+
+    def model_name
+      @model_name ||= model.model_name
+    rescue
+      @model_name = ActiveModel::Name.new(model)
+    end
+
+    def param_key
+      model_name.param_key
+    end
+
+    def finder_param
+      "#{model_name.singular}_#{finder_attribute}"
+    end
+
+    def self.class_for(name)
+      name.to_s.split('::').map(&:classify).join('::').constantize
+    end
+  end
+end

data/lib/resourcerer/resource.rb

@@ -0,0 +1,21 @@
+require 'resourcerer/inflector'
+require 'resourcerer/strategies/strong_parameters_strategy'
+
+module Resourcerer
+  class Resource
+    attr_reader :name, :strategy, :options, :config_proc
+
+    def self.for(name, options={}, config_proc=nil)
+      strategy_class = options.delete(:strategy) || Strategies::StrongParametersStrategy
+      new strategy_class, name, options, config_proc
+    end
+
+    def initialize(strategy, name, options, config_proc=nil)
+      @strategy, @name, @options, @config_proc = strategy, name, options, config_proc
+    end
+
+    def call(controller)
+      strategy.new(controller, name, options, config_proc).resource
+    end
+  end
+end

data/lib/resourcerer/resource_configuration.rb

@@ -0,0 +1,45 @@
+# This is the base class that is intended to build the DSL for Resourcer
+module Resourcerer
+  class ResourceConfiguration
+
+    attr_reader :options
+
+    def initialize(options={})
+      @options = options || {}
+    end
+
+    def attributes
+      @attributes ||= options[:attributes].try(:call)
+    end
+
+    def method_missing(name, *args)
+      super if args.size > 1
+      define_option_method(name)
+      send(name, args.first)
+    end
+
+    def define_option_method(name)
+      # We chose not caching the value inside the method because it's more flexible
+      self.class.class_eval <<-EVAL
+        def #{name}(value=nil)
+          options[:#{name}] = value if value
+          options[:#{name}]
+        end
+      EVAL
+    end
+
+    # DSL
+
+    def find(&block)
+      options[:finder] = block
+    end
+
+    def build(&block)
+      options[:builder] = block
+    end
+
+    def assign(&block)
+      options[:attributes] = block
+    end
+  end
+end

data/lib/resourcerer/resourceable.rb

@@ -0,0 +1,39 @@
+require 'resourcerer/resource'
+require 'simple_memoizer'
+
+module Resourcerer
+  module Resourceable
+    extend ActiveSupport::Concern
+    include SimpleMemoizer
+
+    module ClassMethods
+
+      def _resources
+        @_resources ||= {}
+      end
+
+      def resource(name, options={}, &block)
+        check_method_available!(name)
+        _resources[name] = resource = Resource.for(name, options, block)
+        define_resource_method(name, resource)
+      end
+
+      private
+
+      def define_resource_method(name, resource)
+        define_method(name) { resource.call(self) }
+        memoize name
+        hide_action name, "#{name}="
+      end
+
+      def check_method_available!(name)
+        if self.respond_to?(name.to_sym)
+          Kernel.abort "[ERROR] You are adding a singular resource by the `#{name}` method, " \
+            "which overrides an existing method of the same name. " \
+            "Consider a different resource name\n" \
+            "#{caller.first}"
+        end
+      end
+    end
+  end
+end

data/lib/resourcerer/strategies/assign_attributes.rb

@@ -0,0 +1,34 @@
+module Resourcerer
+  module Strategies
+    module AssignAttributes
+
+      def resource
+        super.tap do |r|
+          assign_attributes(r) if r && assign_attributes?
+        end
+      end
+
+      def attributes
+        config.attributes
+      end
+
+      def assign_attributes?
+        !get? && !delete? && attributes.present?
+      end
+
+      def assign_attributes(resource)
+        resource.attributes = attributes
+      end
+
+      def resource_params
+        params[param_key]
+      end
+
+      private
+
+      def param_key
+        config.param_key || inflector.param_key
+      end
+    end
+  end
+end

data/lib/resourcerer/strategies/assign_from_method.rb

@@ -0,0 +1,23 @@
+require 'resourcerer/strategies/assign_attributes'
+
+module Resourcerer
+  module Strategies
+    module AssignFromMethod
+      include AssignAttributes
+
+      def attributes
+        super || attributes_from_method
+      end
+
+      private
+
+      def attributes_from_method
+        controller.send(attributes_method) if resource_params
+      end
+
+      def attributes_method
+        config.attributes_method || "#{name}_params"
+      end
+    end
+  end
+end

data/lib/resourcerer/strategies/assign_from_params.rb

@@ -0,0 +1,13 @@
+require 'resourcerer/strategies/assign_attributes'
+
+module Resourcerer
+  module Strategies
+    module AssignFromParams
+      include AssignAttributes
+
+      def attributes
+        super || resource_params
+      end
+    end
+  end
+end

data/lib/resourcerer/strategies/default_strategy.rb

@@ -0,0 +1,34 @@
+require 'resourcerer/strategy'
+require 'active_support/core_ext/module/delegation'
+
+module Resourcerer
+  module Strategies
+    class DefaultStrategy < Strategy
+      delegate :get?, :delete?, to: :request
+
+      def resource
+        if id
+          find_resource(id)
+        else
+          build_resource
+        end
+      end
+
+      def id
+        @id ||= params[finder_param] || params[finder_attribute]
+      end
+
+      def finder_param
+        config.finder_param || inflector.finder_param
+      end
+
+      def find_resource(id)
+        config.finder.try(:call, id) || model.find_by(finder_attribute => id)
+      end
+
+      def build_resource
+        config.builder.try(:call) || model.new
+      end
+    end
+  end
+end

data/lib/resourcerer/strategies/eager_attributes_strategy.rb

@@ -0,0 +1,10 @@
+require 'resourcerer/strategies/default_strategy'
+require 'resourcerer/strategies/assign_from_params'
+
+module Resourcerer
+  module Strategies
+    class EagerAttributesStrategy < DefaultStrategy
+      include Strategies::AssignFromParams
+    end
+  end
+end

data/lib/resourcerer/strategies/strong_parameters_strategy.rb

@@ -0,0 +1,10 @@
+require 'resourcerer/strategies/default_strategy'
+require 'resourcerer/strategies/assign_from_method'
+
+module Resourcerer
+  module Strategies
+    class StrongParametersStrategy < DefaultStrategy
+      include Strategies::AssignFromMethod
+    end
+  end
+end

data/lib/resourcerer/strategy.rb

@@ -0,0 +1,55 @@
+require 'resourcerer/inflector'
+require 'resourcerer/resource_configuration'
+
+module Resourcerer
+  class Strategy
+    attr_reader :controller, :name, :options, :config_proc
+    attr_writer :model, :inflector
+
+    def initialize(controller, name, options={}, config_proc=nil)
+      @controller, @name, @options, @config_proc = controller, name.to_s, options, config_proc
+    end
+
+    def resource
+      raise 'Implement in subclass'
+    end
+
+    protected
+
+    # Subclasses may provide an extended version of ResourceConfiguration to extend the DSL
+    def build_configuration(options)
+      ResourceConfiguration.new(options)
+    end
+
+    def config
+      @config ||= build_configuration(options).tap do |rc|
+        rc.instance_eval(&config_proc) if config_proc # This evaluates the configuration in the DSL block
+      end
+    end
+
+    def inflector
+      @inflector ||= Resourcerer::Inflector.new(name, model, finder_attribute)
+    end
+
+    def model
+      @model ||= case config.model
+        when Class, Module
+          config.model
+        else
+          Resourcerer::Inflector.class_for(config.model || name)
+      end
+    end
+
+    def finder_attribute
+      config.finder_attribute || :id
+    end
+
+    def params
+      controller.params
+    end
+
+    def request
+      controller.request
+    end
+  end
+end

data/lib/resourcerer.rb

@@ -0,0 +1,5 @@
+require 'resourcerer/resourceable'
+
+ActiveSupport.on_load(:action_controller) do
+  include Resourcerer::Resourceable
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: resourcerer
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Máximo Mussini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simple_memoizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Extracted from decent exposure, allows you to define resources to automate
+  finding a record and assigning attributes.
+email:
+- maximomussini@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/resourcerer.rb
+- lib/resourcerer/inflector.rb
+- lib/resourcerer/resource.rb
+- lib/resourcerer/resource_configuration.rb
+- lib/resourcerer/resourceable.rb
+- lib/resourcerer/strategies/assign_attributes.rb
+- lib/resourcerer/strategies/assign_from_method.rb
+- lib/resourcerer/strategies/assign_from_params.rb
+- lib/resourcerer/strategies/default_strategy.rb
+- lib/resourcerer/strategies/eager_attributes_strategy.rb
+- lib/resourcerer/strategies/strong_parameters_strategy.rb
+- lib/resourcerer/strategy.rb
+homepage: https://github.com/ElMassimo/resourcerer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Dry up your controllers by defining resources
+test_files: []