decent_exposure 1.0.2 → 2.0.0.rc1

data/README.md

@@ -1,163 +1,356 @@
-`decent_exposure` helps you program to an interface, rather than an implementation in
-your Rails controllers.
-
-Sharing state via instance variables in controllers promotes close coupling with
-views. `decent_exposure` gives you a declarative manner of exposing an interface to the
-state that controllers contain, thereby decreasing coupling and improving your
-testability and overall design. I elaborate on this approach in [A Diatribe on
-Maintaining State][diatribe].
-
-Installation
-------------
-
-    gem install decent_exposure
-
-Configure your Rails 2.X application to use it:
-
-In `config/environment.rb`:
-
-    config.gem 'decent_exposure'
-
-When used in Rails 3:
-
-In `Gemfile`:
-
-    gem 'decent_exposure'
-
-
-Examples
---------
-
-### Railscast
-
-Ryan Bates has a Railscasts episode covering `decent_exposure`. If you're just
-getting started or just enjoy screencasts (Ryan's are always great), you can
-check it out here: [Railscasts - Decent Exposure][railscast].
-
-### A full example
-
-The wiki has a full example of [converting a classic-style Rails
-controller][converting].
-
-### In your controllers
-
-When no block is given, `expose` attempts to determine which resource you want
-to acquire. When `params` contains `:category_id` or `:id`, a call to:
-
-    expose(:category)
-
-Would result in the following `ActiveRecord#find`:
-
-    Category.find(params[:category_id]||params[:id])
-
-As the example shows, the symbol passed is used to guess the class name of the
-object (and potentially the `params` key to find it with) you want an instance
-of.
-
-Should `params` not contain an identifiable `id`, a call to:
-
-    expose(:category)
-
-Will instead attempt to build a new instance of the object like so:
-
-    Category.new(params[:category])
-
-If you define a collection with a pluralized name of the singular resource,
-`decent_exposure` will attempt to use it to scope its calls from. Let's take the
-following scenario:
-
-    class ProductsController < ApplicationController
-      expose(:category)
-      expose(:products) { category.products }
-      expose(:product)
+## Mad Decent
+
+Rails controllers are the sweaty armpit of every rails app. This is due, in
+large part, to the fact that they expose their instance variables directly to
+their views. This means that your instance variables are your interface... and
+that you've broken encapsulation. Instance variables are meant to be private,
+for Science's sake!
+
+What `decent_exposure` proposes is that you go from this:
+
+```ruby
+class Controller
+  def new
+    @person = Person.new(params[:person])
+  end
+
+  def create
+    @person = Person.new(params[:person])
+    if @person.save
+      redirect_to(@person)
+    else
+      render :new
     end
-
-The `product` resource would scope from the `products` collection via a
-fully-expanded query equivalent to this:
-
-    Category.find(params[:category_id]).products.find(params[:id])
-
-or (depending on the contents of the `params` hash) this:
-
-    Category.find(params[:category_id]).products.new(params[:product])
-
-In the straightforward case, the three exposed resources above provide for
-access to both the primary and ancestor resources in a way usable across all 7
-actions in a typicall Rails-style RESTful controller.
-
-#### A Note on Style
-
-When the code has become complex enough to surpass a single line (and is not
-appropriate to extract into a model method), use the `do...end` style of block:
-
-    expose(:associated_products) do
-      product.associated.tap do |associated_products|
-        present(associated_products, :with => AssociatedProductPresenter)
-      end
+  end
+
+  def edit
+    @person = Person.find(params[:id])
+  end
+
+  def update
+    @person = Person.find(params[:id])
+    if @person.update_attributes(params[:person])
+      redirect_to(@person)
+    else
+      render :edit
     end
+  end
+end
+```
 
-### In your views
-
-Use the product of those assignments like you would an instance variable or any
-other method you might normally have access to:
-
-    = render bread_crumbs_for(category)
-    %h3#product_title= product.title
-    = render product
-    %h3 Associated Products
-    %ul
-      - associated_products.each do |associated_product|
-      %li= link_to(associated_product.title,product_path(associated_product))
-
-### Custom defaults
+To something like this:
 
-`decent_exposure` provides opinionated default logic when `expose` is invoked without
-a block. It's possible, however, to override this with custom default logic by
-passing a block accepting a single argument to the `default_exposure` method
-inside of a controller. The argument will be the string or symbol passed in to
-the `expose` call.
+```ruby
+class Controller
+  expose(:person)
 
-    class MyController < ApplicationController
-      default_exposure do |name|
-        ObjectCache.load(name.to_s)
-      end
+  def create
+    if person.save
+      redirect_to(person)
+    else
+      render :new
     end
+  end
 
-The given block will be invoked in the context of a controller instance. It is
-possible to provide a custom default for a descendant class without disturbing
-its ancestor classes in an inheritance heirachy.
-
-Beware
-------
-
-This is a simple tool, which provides a solitary solution. It must be used in
-conjunction with solid design approaches ("Program to an interface, not an
-implementation.") and accepted best practices (e.g. Fat Model, Skinny
-Controller). In itself, it won't heal a bad design. It is meant only to be a
-tool to use in improving the overall design of a Ruby on Rails system and
-moreover to provide a standard implementation for an emerging best practice.
-
-Development
------------
-
-### Running specs
-
-`decent_exposure` has been developed with the philosophy that Ruby developers shouldn't
-force their choice in RubyGems package managers on people consuming their code.
-As a side effect of that, if you attempt to run the specs on this application,
-you might get `no such file to load` errors.  The short answer is that you can
-`export RUBYOPT='rubygems'` and be on about your way (for the long answer, see
-Ryan Tomayko's [excellent treatise][treatise] on the subject).
-
-[treatise]: http://tomayko.com/writings/require-rubygems-antipattern
-[converting]: http://github.com/voxdolo/decent_exposure/wiki/Examples
-[diatribe]: http://blog.voxdolo.me/a-diatribe-on-maintaining-state.html
-[railscast]: http://railscasts.com/episodes/259-decent-exposure
-
-Contributors
-------------
-
-Thanks to everyone that's helped out with `decent_exposure`! You can see a full
-list here:
-
-<http://github.com/voxdolo/decent_exposure/contributors>
+  def update
+    if person.save
+      redirect_to(person)
+    else
+      render :edit
+    end
+  end
+end
+```
+
+`decent_exposure` makes it easy to define named methods that are made available
+to your views and which memoize the resultant values. It also tucks away the
+details of the common fetching, initializing and updating of resources and
+their parameters.
+
+That's neat and all, but the real advantage comes when it's time to refactor
+(because you've encapsulated now). What happens when you need to scope your
+`Person` resource from a `Company`? Which implementation isolates those changes
+better? In that particular example, `decent_exposure` goes one step farther and
+will handle the scoping for you (with a smidge of configuration) while still
+handling all that repetitive initialization, as we'll see next.
+
+Even if you decide not to use `decent_exposure`, do yourself a favor and stop
+using instance variables in your views. Your code will be cleaner and easier to
+refactor as a result. If you want to learn more about his approach, I've
+expanded on my thoughts in the article [A Diatribe on Maintaining State][1].
+
+## Environmental Awareness
+
+Well, no it won't lessen your carbon footprint, but it does take a lot of
+cues from what's going on around it...
+
+`decent_exposure` will build the requested object in one of a couple of ways
+depending on what the `params` make available to it. At its simplest, when an
+`id` is present in the `params` hash, `decent_exposure` will attempt to find a
+record. In absence of `params[:id]` `decent_exposure` will try to build a new
+record.
+
+Once the object has been obtained, it attempts to set the attributes of the
+resulting object. Thus, a newly minted `person` instance will get any
+attributes set that've been passed along in `params[:person]`.  When you
+interact with `person` in your create action, just call save on it and handle
+the valid/invalid branch. Let's revisit our previous example:
+
+```ruby
+class Controller
+  expose(:person)
+
+  def create
+    if person.save
+      redirect_to(person)
+    else
+      render :new
+    end
+  end
+end
+```
+
+Behind the scenes, `decent_exposure` has essentially done this:
+
+```ruby
+person.attributes = params[:person]
+```
+
+In Rails, this assignment is actually a merge with the current attributes and
+it marks attributes as dirty as you would expect. This is why you're simply
+able to call `save` on the `person` instance in the create action, rather than
+the typical `update_attributes(params[:person])`.
+
+**An Aside**
+
+Did you notice there's no `new` action? Yeah, that's because we don't need it.
+More often than not actions that respond to `GET` requests are just setting up
+state. Since we've declared an interface to our state and made it available to
+the view (a.k.a. the place where we actually want to access it), we just let
+Rails do it's magic and render the `new` view, lazily evaluating `person` when
+we actually need it.
+
+**A Caveat**
+
+Rails conveniently responds with a 404 if you get a record not found in the
+controller. Since we don't find the object until we're in the view in this
+paradigm, we get an ugly `ActionView::TemplateError` instead. If this is
+problematic for you, consider using the `expose!` method to circumvent lazy
+evaluation and eagerly evaluate whilst still in the controller.
+
+## Usage
+
+In an effort to make the examples below a bit less magical, we'll offer a
+simplified explanation for how the exposed resource would be queried for
+(assuming you are using `ActiveRecord`).
+
+### Obtaining an instance of an object:
+
+```ruby
+expose(:person)
+```
+
+**Query Explanation**
+
+<table>
+  <tr>
+    <td><code>id</code> present?</td>
+    <td>Query</td>
+  </tr>
+  <tr>
+    <td><code>true</code></td>
+    <td><code>Person.find(params[:id])</code></td>
+  </tr>
+  <tr>
+    <td><code>false</code></td>
+    <td><code>Person.new(params[:person])</code></td>
+  </tr>
+</table>
+
+### Obtaining a collection of objects
+
+```ruby
+expose(:people)
+```
+
+**Query Explanation**
+
+<table>
+  <tr>
+    <td>Query</td>
+  </tr>
+  <tr>
+    <td><code>Person.scoped</code></td>
+  </tr>
+</table>
+
+### Scoping your object queries
+
+Want to scope your queries to ensure object hierarchy? `decent_exposure`
+automatically scopes singular forms of a resource from a plural form where
+they're defined:
+
+```ruby
+expose(:people)
+expose(:person)
+```
+
+**Query Explanation**
+
+<table>
+  <tr>
+    <td><code>id</code> present?</td>
+    <td>Query</td>
+  </tr>
+  <tr>
+    <td><code>true</code></td>
+    <td><code>Person.scoped.find(params[:id])</code></td>
+  </tr>
+  <tr>
+    <td><code>false</code></td>
+    <td><code>Person.scoped.new(params[:person])</code></td>
+  </tr>
+</table>
+
+How about a more realistic scenario where the object hierarchy specifies
+something useful, like only finding people in a given company:
+
+```ruby
+expose(:company)
+expose(:people, ancestor: :company)
+expose(:person)
+```
+
+**Query Explanation**
+
+<table>
+  <tr>
+    <td>person <code>id</code> present?</td>
+    <td>Query</td>
+  </tr>
+  <tr>
+    <td><code>true</code></td>
+    <td><code>Company.find(params[:company_id]).people.find(params[:id])</code></td>
+  </tr>
+  <tr>
+    <td><code>false</code></td>
+    <td><code>Company.find(params[:company_id]).people.new(params[:person])</code></td>
+  </tr>
+</table>
+
+### Further configuration
+
+`decent_exposure` is a configurable beast. Let's take a look at some of the
+things you can do:
+
+**Specify the model name:**
+
+```ruby
+expose(:company, model: :enterprisey_company)
+```
+
+**Specify the parameter accessor method:**
+
+```ruby
+expose(:company, params: :company_params)
+```
+
+**Specify the finder method:**
+
+```ruby
+expose(:article, finder: :find_by_slug)
+```
+
+**Specify the parameter key to use to fetch the object:**
+
+```ruby
+expose(:article, finder_parameter: :slug)
+```
+
+### Getting your hands dirty
+
+While we try to make things as easy for you as possible, sometimes you just
+need to go off the beaten path. For those times, `expose` takes a block which
+it lazily evaluates and returns the result of when called. So for instance:
+
+```ruby
+expose(:environment) { Rails.env }
+```
+
+This block is evaluated and the memoized result is returned whenever you call
+`environment`.
+
+### Custom strategies
+
+For the times when custom behavior is needed for resource finding,
+`decent_exposure` provides a base class for extending. For example, if
+scoping a resource from `current_user` is not and option, but you'd like
+to verify a resource's relationship to the `current_user`, you can use a
+custom strategy like the following:
+
+```ruby
+class VerifiableStrategy < DecentExposure::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
+expose(:post, strategy: VerifiableStrategy)
+```
+
+The API only necessitates you to define `resource`, but provides some
+common helpers to access common things, such as the `params` hash. For
+everything else, you can delegate to `controller`, which is the same as
+`self` in the context of a normal controller action.
+
+### Customizing your exposures
+
+For most things, you'll be able to pass a few configuration options and get
+the desired behavior. For changes you want to affect every call to `expose` in
+a controller or controllers inheriting from it (e.g. `ApplicationController`,
+if you need to change the behavior for all your controllers), you can define
+an `decent_configuration` block:
+
+```ruby
+class ApplicationController < ActionController::Base
+  decent_configuration do
+    strategy MongoidStrategy
+  end
+end
+```
+
+A `decent_configuration` block without a `:name` argument is considered the
+"default" configuration for that controller (and it's ancestors).  All things
+considered, you probably only want to change the strategy in a default.
+Nonetheless, you can pass any configuration option you can to an individual
+exposure to the `decent_configuration` block.
+
+If you don't want a specific configuration to affect every exposure in the
+given controller, you can give it a name like so:
+
+```ruby
+class ArticleController < ApplicationController
+  decent_configuration(:sluggable) do
+    finder :find_by_slug
+    finder_parameter :slug
+  end
+end
+```
+
+And opt into it like so:
+
+```ruby
+expose(:article, config: :sluggable)
+```
+
+[1]: http://blog.voxdolo.me/a-diatribe-on-maintaining-state.html

data/lib/decent_exposure.rb

@@ -1,34 +1,5 @@
-require 'decent_exposure/railtie'
+require 'decent_exposure/expose'
 
-module DecentExposure
-  def inherited(klass)
-    closured_exposure = default_exposure
-    klass.class_eval do
-      default_exposure(&closured_exposure)
-    end
-    super
-  end
-
-  attr_accessor :_default_exposure
-
-  def default_exposure(&block)
-    self._default_exposure = block if block_given?
-    _default_exposure
-  end
-
-  def expose(name, &block)
-    closured_exposure = default_exposure
-    define_method name do
-      @_resources       ||= {}
-      @_resources.fetch(name) do
-        @_resources[name] = if block_given?
-          instance_eval(&block)
-        else
-          instance_exec(name, &closured_exposure)
-        end
-      end
-    end
-    helper_method name
-    hide_action name
-  end
+ActiveSupport.on_load(:action_controller) do
+  extend DecentExposure::Expose
 end

data/lib/decent_exposure/active_record_strategy.rb

@@ -0,0 +1,68 @@
+require 'decent_exposure/strategy'
+require 'active_support/core_ext/module/delegation'
+
+module DecentExposure
+  class ActiveRecordStrategy < Strategy
+    delegate :plural?, :parameter, :to => :inflector
+
+    def collection
+      inflector.plural.to_sym
+    end
+
+    def scope
+      if options[:ancestor]
+        ancestor_scope
+      else
+        default_scope
+      end
+    end
+
+    def ancestor_scope
+      if plural?
+        controller.send(options[:ancestor]).send(inflector.plural)
+      else
+        controller.send(options[:ancestor])
+      end
+    end
+
+    def default_scope
+      if controller.respond_to?(collection) && !plural?
+        controller.send(collection)
+      else
+        model
+      end
+    end
+
+    def finder
+      options[:finder] || :find
+    end
+
+    def collection_resource
+      scope.scoped
+    end
+
+    def id
+      params[parameter] || params[finder_parameter]
+    end
+
+    def finder_parameter
+      options[:finder_parameter] || :id
+    end
+
+    def singular_resource
+      if id
+        scope.send(finder, id)
+      else
+        scope.new
+      end
+    end
+
+    def resource
+      if plural?
+        collection_resource
+      else
+        singular_resource
+      end
+    end
+  end
+end

data/lib/decent_exposure/active_record_with_eager_attributes_strategy.rb

@@ -0,0 +1,30 @@
+require 'decent_exposure/active_record_strategy'
+
+module DecentExposure
+  class ActiveRecordWithEagerAttributesStrategy < ActiveRecordStrategy
+    delegate :get?, :to => :request
+
+    def singular?
+      !plural?
+    end
+
+    def attributes
+      params[inflector.singular]
+    end
+
+    def assign_attributes?
+      return false unless attributes && singular?
+      !get? || new_record?
+    end
+
+    def new_record?
+      !id
+    end
+
+    def resource
+      super.tap do |r|
+        r.attributes = attributes if assign_attributes?
+      end
+    end
+  end
+end

data/lib/decent_exposure/configuration.rb

@@ -0,0 +1,19 @@
+module DecentExposure
+  class Configuration
+    def initialize(&block)
+      instance_exec(&block) if block_given?
+    end
+
+    def merge(other)
+      options.merge(other)
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def method_missing(key,value)
+      self.options[key] = value
+    end
+  end
+end

data/lib/decent_exposure/expose.rb

@@ -0,0 +1,60 @@
+require 'decent_exposure/strategizer'
+require 'decent_exposure/configuration'
+
+module DecentExposure
+  module Expose
+    def self.extended(base)
+      base.class_eval do
+        class_attribute :_default_exposure
+        def _resources
+          @_resources ||= {}
+        end
+        hide_action :_resources
+      end
+    end
+
+    def _exposures
+      @_exposures ||= {}
+    end
+
+    def _decent_configurations
+      @_decent_configurations ||= Hash.new(Configuration.new)
+    end
+
+    def decent_configuration(name=:default,&block)
+      _decent_configurations[name] = Configuration.new(&block)
+    end
+
+    def default_exposure(&block)
+      warn "[DEPRECATION] `default_exposure` is deprecated, and will " \
+      "be removed in DecentExposure 2.1 without a replacement.  Please " \
+      "use a custom strategy instead.\n" \
+      "#{caller.first}"
+      self._default_exposure = block
+    end
+
+    def expose!(*args, &block)
+      set_callback(:process_action, :before, args.first)
+      expose(*args, &block)
+    end
+
+    def expose(name, options={:default_exposure => _default_exposure}, &block)
+      config = options[:config] || :default
+      options = _decent_configurations[config].merge(options)
+
+      _exposures[name] = exposure = Strategizer.new(name, options, &block).strategy
+
+      define_method(name) do
+        return _resources[name] if _resources.has_key?(name)
+        _resources[name] = exposure.call(self)
+      end
+
+      define_method("#{name}=") do |value|
+        _resources[name] = value
+      end
+
+      helper_method name
+      hide_action name
+    end
+  end
+end

data/lib/decent_exposure/exposure.rb

@@ -0,0 +1,17 @@
+require 'decent_exposure/inflector'
+
+module DecentExposure
+  class Exposure
+    attr_accessor :inflector, :strategy, :options
+
+    def initialize(name, strategy, options)
+      self.strategy = strategy
+      self.options = options
+      self.inflector = DecentExposure::Inflector.new(name)
+    end
+
+    def call(controller)
+      strategy.new(controller, inflector, options).resource
+    end
+  end
+end

data/lib/decent_exposure/inflector.rb

@@ -0,0 +1,34 @@
+require 'active_support/inflector'
+require 'active_support/core_ext/string/inflections'
+
+module DecentExposure
+  class Inflector
+    attr_reader :original
+    alias name original
+
+    def initialize(name)
+      @original = name.to_s
+    end
+
+    def constant
+      original.classify.constantize
+    end
+
+    def parameter
+      singular + "_id"
+    end
+
+    def singular
+      original.parameterize
+    end
+
+    def plural
+      original.pluralize
+    end
+    alias collection plural
+
+    def plural?
+      plural == original
+    end
+  end
+end

data/lib/decent_exposure/strategizer.rb

@@ -0,0 +1,60 @@
+require 'decent_exposure/exposure'
+require 'decent_exposure/active_record_with_eager_attributes_strategy'
+
+module DecentExposure
+  class Strategizer
+    attr_accessor :name, :block, :default_exposure, :options, :custom_strategy_class
+
+    def initialize(name, options={})
+      self.name = name
+      self.default_exposure = options.delete(:default_exposure)
+      self.custom_strategy_class = options.delete(:strategy)
+      self.options = options
+      self.block = Proc.new if block_given?
+    end
+
+    def strategy
+      [block_strategy,
+       default_exposure_strategy,
+       exposure_strategy].detect(&applicable)
+    end
+
+    def model
+      options[:model] || name
+    end
+
+    private
+
+    def applicable
+      lambda { |s| s }
+    end
+
+    def exposure_strategy
+      Exposure.new(model, exposure_strategy_class, options)
+    end
+
+    def block_strategy
+      BlockStrategy.new(block) if block
+    end
+
+    def default_exposure_strategy
+      DefaultStrategy.new(name, default_exposure) if default_exposure
+    end
+
+    def exposure_strategy_class
+      custom_strategy_class || ActiveRecordWithEagerAttributesStrategy
+    end
+  end
+
+  DefaultStrategy = Struct.new(:name, :block) do
+    def call(controller)
+      controller.instance_exec(name, &block)
+    end
+  end
+
+  BlockStrategy = Struct.new(:block) do
+    def call(controller)
+      controller.instance_eval(&block)
+    end
+  end
+end

data/lib/decent_exposure/strategy.rb

@@ -0,0 +1,37 @@
+module DecentExposure
+  class Strategy
+    attr_reader :controller, :inflector, :options
+
+    def initialize(controller, inflector, options={})
+      @controller, @inflector, @options = controller, inflector, options
+    end
+
+    def name
+      inflector.name
+    end
+
+    def resource
+      raise 'Implement in subclass'
+    end
+
+    protected
+
+    def model
+      inflector.constant
+    end
+
+    def params
+      controller.send(params_method)
+    end
+
+    def request
+      controller.request
+    end
+
+    private
+
+    def params_method
+      options[:params] || :params
+    end
+  end
+end

data/lib/decent_exposure/version.rb

@@ -1,3 +1,3 @@
 module DecentExposure #:nodoc
-  VERSION = "1.0.2"
+  VERSION = "2.0.0.rc1"
 end

metadata

@@ -1,72 +1,62 @@
 --- !ruby/object:Gem::Specification
 name: decent_exposure
 version: !ruby/object:Gem::Version
-  version: 1.0.2
-  prerelease: 
+  version: 2.0.0.rc1
+  prerelease: 6
 platform: ruby
 authors:
 - Stephen Caudill
 - Jon Larkowski
+- Joshua Davey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-08 00:00:00.000000000Z
+date: 2012-07-27 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70182141020280 !ruby/object:Gem::Requirement
+  requirement: &70110875340260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: '2.7'
   type: :development
   prerelease: false
-  version_requirements: *70182141020280
+  version_requirements: *70110875340260
 - !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: &70182141019820 !ruby/object:Gem::Requirement
+  name: rspec-rails
+  requirement: &70110875338840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.12
+        version: '2.7'
   type: :development
   prerelease: false
-  version_requirements: *70182141019820
-- !ruby/object:Gem::Dependency
-  name: ruby-debug19
-  requirement: &70182141019360 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.11.6
-  type: :development
-  prerelease: false
-  version_requirements: *70182141019360
+  version_requirements: *70110875338840
 - !ruby/object:Gem::Dependency
   name: actionpack
-  requirement: &70182141018980 !ruby/object:Gem::Requirement
+  requirement: &70110875338380 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
-  version_requirements: *70182141018980
+  version_requirements: *70110875338380
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70182141018520 !ruby/object:Gem::Requirement
+  requirement: &70110875337880 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
-  version_requirements: *70182141018520
+  version_requirements: *70110875337880
 description: ! "\n    DecentExposure helps you program to an interface, rather than
   an\n    implementation in your Rails controllers.  The fact of the matter is that\n
   \   sharing state via instance variables in controllers promotes close coupling\n
@@ -78,14 +68,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/decent_exposure/default_exposure.rb
-- lib/decent_exposure/railtie.rb
+- lib/decent_exposure/active_record_strategy.rb
+- lib/decent_exposure/active_record_with_eager_attributes_strategy.rb
+- lib/decent_exposure/configuration.rb
+- lib/decent_exposure/expose.rb
+- lib/decent_exposure/exposure.rb
+- lib/decent_exposure/inflector.rb
+- lib/decent_exposure/strategizer.rb
+- lib/decent_exposure/strategy.rb
 - lib/decent_exposure/version.rb
 - lib/decent_exposure.rb
 - README.md
-- COPYING
-- init.rb
-- rails/init.rb
 homepage: http://github.com/voxdolo/decent_exposure
 licenses: []
 post_install_message: 
@@ -107,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A helper for creating declarative interfaces in controllers

data/COPYING

@@ -1,12 +0,0 @@
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-                    Version 2, December 2004
-
- Everyone is permitted to copy and distribute verbatim or modified
- copies of this license document, and changing it is allowed as long
- as the name is changed.
-
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. You just DO WHAT THE FUCK YOU WANT TO. 
-

data/init.rb

@@ -1,2 +0,0 @@
-require 'decent_exposure/railtie'
-DecentExposure::Railtie.insert

data/lib/decent_exposure/default_exposure.rb

@@ -1,28 +0,0 @@
-module DecentExposure
-  module DefaultExposure
-    def self.included(klass)
-      klass.extend(DecentExposure)
-      if klass.respond_to?(:class_attribute)
-        klass.class_attribute(:_default_exposure)
-      else
-        klass.superclass_delegating_accessor(:_default_exposure)
-      end
-      klass.default_exposure do |name|
-        collection = name.to_s.pluralize
-        if respond_to?(collection) && collection != name.to_s && send(collection).respond_to?(:scoped)
-          proxy = send(collection)
-        else
-          proxy = name.to_s.classify.constantize
-        end
-
-        if id = params["#{name}_id"] || params[:id]
-          proxy.find(id).tap do |r|
-            r.attributes = params[name] unless request.get?
-          end
-        else
-          proxy.new(params[name])
-        end
-      end
-    end
-  end
-end

data/lib/decent_exposure/railtie.rb

@@ -1,20 +0,0 @@
-require 'decent_exposure/default_exposure'
-
-module DecentExposure
-  if defined? Rails::Railtie
-    class Railtie < Rails::Railtie
-      initializer "decent_exposure.extend_action_controller_base" do |app|
-        ActiveSupport.on_load(:action_controller) do
-          DecentExposure::Railtie.insert
-        end
-      end
-    end
-  end
-
-  class Railtie
-    def self.insert
-      ActionController::Base.send(:include, DecentExposure::DefaultExposure)
-      ActionController::Base.protected_instance_variables.push("@_resources")
-    end
-  end
-end

data/rails/init.rb

@@ -1 +0,0 @@
-Kernel.load File.join(File.dirname(__FILE__), '..', 'init.rb')