garden_variety 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9e0504f9a8b485b41628697e9b5b3061e697874d
+  data.tar.gz: 69d7067b8054ce75955a12cf47420901f4badf0b
+SHA512:
+  metadata.gz: 3cb5e7ee8a146481586d7aa7efabdd48efa03e34617c3f9cd6e46bab3a8730210cc12d3ad9c1ec5d9d17daa675b17b8f08ae6481ac8545a8cc27f7a830b9fe40
+  data.tar.gz: 1e02647816ee226bf0d46dc7933e74aff5f28a465abbf75d4722d2e69c287581b7b2da56cfbc7fd7fe629705cd19d8beb6eb800b8a7d7e0ff786b276287d822e

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 
+
+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,382 @@
+# garden_variety
+
+Delightfully boring Rails controllers.  One of the superb advantages of
+Ruby on Rails is convention over configuration.  Opinionated default
+behavior can decrease development time, and increase application
+robustness (less custom code == less that can go wrong).  In service of
+this principle, *garden_variety* provides reasonable default controller
+actions, with care to allow easy override.
+
+*garden_variety* also uses the excellent
+[Pundit](https://rubygems.org/gems/pundit) gem to isolate authorization
+concerns.  If you're unfamiliar with Pundit, see its documentation for
+an explanation of policy objects and how they help controller actions
+stay DRY and boring.
+
+As an example, this controller using `garden_variety`...
+
+```ruby
+class PostsController < ApplicationController
+  garden_variety
+end
+```
+
+...expands to the following conventional implementation:
+
+```ruby
+class PostsController < ApplicationController
+
+  def index
+    authorize(resource_class)
+    self.resources = policy_scope(list_resources)
+  end
+
+  def show
+    self.resource = find_resource
+    authorize(resource)
+  end
+
+  def new
+    self.resource = new_resource
+    authorize(resource)
+  end
+
+  def create
+    self.resource = vest(new_resource)
+    if resource.save
+      redirect_to resource
+    else
+      render :new
+    end
+  end
+
+  def edit
+    self.resource = find_resource
+    authorize(resource)
+  end
+
+  def update
+    self.resource = vest(find_resource)
+    if resource.save
+      redirect_to resource
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    self.resource = find_resource
+    authorize(resource)
+    resource.destroy
+    redirect_to action: :index
+  end
+
+  private
+
+  def resource_class
+    Post
+  end
+
+  def resources
+    @posts
+  end
+
+  def resources=(models)
+    @posts = models
+  end
+
+  def resource
+    @post
+  end
+
+  def resource=(model)
+    @post = model
+  end
+
+  def list_resources
+    resource_class.all
+  end
+
+  def find_resource
+    resource_class.find(params[:id])
+  end
+
+  def new_resource
+    resource_class.new
+  end
+
+  def vest(model)
+    authorize(model)
+    model.assign_attributes(permitted_attributes(model))
+    model
+  end
+
+end
+```
+
+The implementations of the `resource_class` and `resource` / `resources`
+accessor methods are generated based on the controller name.  They can
+be altered with an optional argument to the `garden_variety` macro.  The
+rest of the methods can be overridden as normal, a la carte.  For a
+detailed description of method behavior, see the
+[full documentation](http://www.rubydoc.info/gems/garden_variety/).
+(Note that the `authorize`, `policy_scope`, and `permitted_attributes`
+methods are provided by Pundit.)
+
+
+## Scaffold generator
+
+*garden_variety* includes a scaffold generator similar to the Rails
+scaffold generator:
+
+```
+$ rails generate garden:scaffold post title:string body:text published:boolean
+    generate  resource
+      invoke  active_record
+      create    db/migrate/19991231235959_create_posts.rb
+      create    app/models/post.rb
+      invoke    test_unit
+      create      test/models/post_test.rb
+      create      test/fixtures/posts.yml
+      invoke  controller
+      create    app/controllers/posts_controller.rb
+      invoke    erb
+      create      app/views/posts
+      invoke    test_unit
+      create      test/controllers/posts_controller_test.rb
+      invoke    helper
+      create      app/helpers/posts_helper.rb
+      invoke      test_unit
+      invoke    assets
+      invoke      coffee
+      create        app/assets/javascripts/posts.coffee
+      invoke      scss
+      create        app/assets/stylesheets/posts.scss
+      invoke  resource_route
+       route    resources :posts
+    generate  erb:scaffold
+       exist  app/views/posts
+      create  app/views/posts/index.html.erb
+      create  app/views/posts/edit.html.erb
+      create  app/views/posts/show.html.erb
+      create  app/views/posts/new.html.erb
+      create  app/views/posts/_form.html.erb
+      insert  app/controllers/posts_controller.rb
+    generate  pundit:policy
+      create  app/policies/post_policy.rb
+      invoke  test_unit
+      create    test/policies/post_policy_test.rb
+```
+
+The generated controller will contain only a call to the
+`garden_variety` macro.  Also, as you can see from the command output,
+the *garden_variety* scaffold generator differs from the Rails scaffold
+generator in a few small ways:
+
+* No scaffold CSS (i.e. no "app/assets/stylesheets/scaffolds.scss").
+* No jbuilder templates.  Only HTML templates are generated.
+* `rails generate pundit:policy` is invoked for the specified model.
+
+
+## Beyond garden variety behavior
+
+*garden_variety* is designed to reduce the amount of custom code
+written, including in situations where custom code is unavoidable.
+
+
+### Integrating with search
+
+It is possible to integrate searching functionality by overriding the
+`index` action.  However, it can be simpler to override the
+`list_resources` method instead:
+
+```ruby
+class PostsController < ApplicationController
+  garden_variety
+
+  def list_resources
+    params[:author] ? super.where(author: params[:author]) : super
+  end
+end
+```
+
+
+### Integrating with pagination
+
+Your favorite pagination gem (*may I suggest
+[foliate](https://rubygems.org/gems/foliate)?*) can also be integrated
+by overriding the `list_resources` action:
+
+```ruby
+class PostsController < ApplicationController
+  garden_variety
+
+  def list_resources
+    paginate(super)
+  end
+end
+```
+
+
+### Integrating with authentication
+
+The details of integrating authentication will depend on your chosen
+authentication library.  [Devise](https://rubygems.org/gems/devise) is a
+popular gem, but I prefer [Clearance](https://rubygems.org/gems/clearance)
+for its simplicity and concision.  Whatever library you choose, it is
+likely to include a "before filter" which you must invoke in your
+controller to enforce authentication.  Something similar to the
+following:
+
+```ruby
+class PostsController < ApplicationController
+  garden_variety
+  before_action :require_login
+end
+```
+
+Your authentication library is also likely to provide a `current_user`
+method, which will return an appropriate value when the user is
+authenticated.  Pundit automatically uses this method to enforce
+authorization policies.  See your authentication library's documentation
+to verify that it provides this method, or see Pundit's documentation
+for details on using a different method to identify the current user.
+
+*garden_variety* also provides a stub implementation of `current_user`,
+so that if no authentication library is chosen, `current_user` will be
+defined to always return nil.
+
+**Note about Clearance:** Clearance versions previous to 2.0 define a
+deprecated `authorize` method which conflicts with Pundit.  To avoid
+this conflict, add the following line to your ApplicationController or
+Clearance initializer:
+
+```ruby
+::Clearance::Controller.send(:remove_method, :authorize)
+```
+
+
+### Integrating with Form Objects
+
+The Form Object pattern is used to mitigate the complexity of handling
+forms which need special processing logic, such as context-dependent
+validation, or forms which involve more than one model.  A detailed
+explanation of the pattern is beyond the scope of this document, but
+consider the following minimal example:
+
+```ruby
+class RegistrationForm
+  include ActiveModel::Model
+
+  attr_accessor :email, :password, :accept_terms_of_service
+
+  validates :accept_terms_of_service, presence: true, acceptance: true
+
+  def save
+    @user = User.new(email: email, password: password)
+    if [valid?, @user.valid?].all?
+      @user.save
+    else
+      @user.errors.each{|attr, message| errors.add(attr, message) }
+      false
+    end
+  end
+end
+
+
+class RegistrationFormsController < ApplicationController
+  garden_variety :new
+
+  def create
+    self.resource = vest(new_resource)
+    if resource.save
+      redirect_to root_path # redirect to front page instead of show
+    else
+      render :new
+    end
+  end
+end
+```
+
+Only the `new` controller action is generated by the `garden_variety`
+macro.  The `create` action is implemented directly in order to redirect
+to `root_path` rather than the resource itself, as would be
+conventional.  The *garden_variety* helper methods all work as expected
+because `RegistrationForm` responds to `assign_attributes` and `save`,
+and has a default (nullary) constructor.
+
+
+### Non-REST actions
+
+You may also define any non-REST controller actions you wish (i.e.
+actions other than: `index`, `show`, `new`, `create`, `edit`, `update`,
+and `destroy`).  The helper methods *garden_variety* provides may be
+useful when doing so.
+
+However, before implementing a non-REST controller action, consider if
+the behavior might be better implemented as a REST action in a new
+controller.  For example, instead of the following `published` action...
+
+```ruby
+class PostsController < ApplicationController
+  garden_variety
+
+  def published
+    @posts = Post.where(published: true)
+    render :index
+  end
+end
+```
+
+...consider a new controller:
+
+```ruby
+class PublishedPostsController < ApplicationController
+  garden_variety :index, resources: :posts
+
+  def list_resources
+    super.where(published: true)
+  end
+end
+```
+
+Note the `resources:` argument to the `garden_variety` macro.  The
+resource class for `PublishedPostsController` will be overridden as
+`Post` instead of derived as `PublishedPost`.  Likewise, the `@posts`
+instance variable will be used instead of `@published_posts`.
+
+This example may be somewhat contrived, but there is an excellent talk
+from RailsConf which delves deeper into the principle:
+[In Relentless Pursuit of REST](https://www.youtube.com/watch?v=HctYHe-YjnE).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "garden_variety"
+```
+
+Then execute:
+
+```bash
+$ bundle
+```
+
+And finally, if you haven't already used and installed Pundit, run the
+Pundit installation generator:
+
+```bash
+$ rails generate pundit:install
+```
+
+
+## Contributing
+
+Run `rake test` to run the tests.
+
+
+## License
+
+[MIT License](https://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1,29 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'yard'
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+end
+
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/garden_variety/actions.rb

@@ -0,0 +1,89 @@
+module GardenVariety
+
+  module IndexAction
+    # Garden variety controller +index+ action.
+    # @return [void]
+    def index
+      authorize(resource_class)
+      self.resources = policy_scope(list_resources)
+    end
+  end
+
+  module ShowAction
+    # Garden variety controller +show+ action.
+    # @return [void]
+    def show
+      self.resource = find_resource
+      authorize(resource)
+    end
+  end
+
+  module NewAction
+    # Garden variety controller +new+ action.
+    # @return [void]
+    def new
+      self.resource = new_resource
+      authorize(resource)
+    end
+  end
+
+  module CreateAction
+    # Garden variety controller +create+ action.
+    # @return [void]
+    def create
+      self.resource = vest(new_resource)
+      if resource.save
+        redirect_to resource
+      else
+        render :new
+      end
+    end
+  end
+
+  module EditAction
+    # Garden variety controller +edit+ action.
+    # @return [void]
+    def edit
+      self.resource = find_resource
+      authorize(resource)
+    end
+  end
+
+  module UpdateAction
+    # Garden variety controller +update+ action.
+    # @return [void]
+    def update
+      self.resource = vest(find_resource)
+      if resource.save
+        redirect_to resource
+      else
+        render :edit
+      end
+    end
+  end
+
+  module DestroyAction
+    # Garden variety controller +destroy+ action.
+    # @return [void]
+    def destroy
+      self.resource = find_resource
+      authorize(resource)
+      resource.destroy
+      redirect_to action: :index
+    end
+  end
+
+  # Map of controller action name to action module.  Used by the
+  # {GardenVariety::Controller::ClassMethods#garden_variety} macro to
+  # include desired controller actions.
+  ACTION_MODULES = {
+    index: IndexAction,
+    show: ShowAction,
+    new: NewAction,
+    create: CreateAction,
+    edit: EditAction,
+    update: UpdateAction,
+    destroy: DestroyAction,
+  }
+
+end

data/lib/garden_variety/controller.rb

@@ -0,0 +1,226 @@
+require "pundit"
+require "garden_variety/actions"
+
+module GardenVariety
+  module Controller
+    extend ActiveSupport::Concern
+
+    include Pundit
+
+    module ClassMethods
+      # Macro to include garden variety implementations of specified
+      # actions in the controller.  If no actions are specified, all
+      # typical REST actions (index, show, new, create, edit, update,
+      # destroy) are included.
+      #
+      # The optional +resources:+ parameter dictates which model class
+      # and instance variables these actions use.  The parameter's
+      # default value derives from the controller name.  The value must
+      # be a resource name in plural form.
+      #
+      # The macro also defines the following accessor methods for use in
+      # generic action and helper methods: +resources+, +resources=+,
+      # +resource+, and +resource=+.  These accessors get and set the
+      # instance variables dictated by the +resources:+ parameter.
+      #
+      # @example default usage
+      #   # This...
+      #   class PostsController < ApplicationController
+      #     garden_variety
+      #   end
+      #
+      #   # ...is equivalent to:
+      #   class PostsController < ApplicationController
+      #     include GardenVariety::IndexAction
+      #     include GardenVariety::ShowAction
+      #     include GardenVariety::NewAction
+      #     include GardenVariety::CreateAction
+      #     include GardenVariety::EditAction
+      #     include GardenVariety::UpdateAction
+      #     include GardenVariety::DestroyAction
+      #
+      #     private
+      #
+      #     def resource_class
+      #       Post
+      #     end
+      #
+      #     def resources
+      #       @posts
+      #     end
+      #
+      #     def resources=(models)
+      #       @posts = models
+      #     end
+      #
+      #     def resource
+      #       @post
+      #     end
+      #
+      #     def resource=(model)
+      #       @post = model
+      #     end
+      #   end
+      #
+      # @example custom usage
+      #   # This...
+      #   class CountriesController < ApplicationController
+      #     garden_variety :index, resources: :locations
+      #   end
+      #
+      #   # ...is equivalent to:
+      #   class CountriesController < ApplicationController
+      #     include GardenVariety::IndexAction
+      #
+      #     private
+      #
+      #     def resource_class
+      #       Location
+      #     end
+      #
+      #     def resources
+      #       @locations
+      #     end
+      #
+      #     def resources=(models)
+      #       @locations = models
+      #     end
+      #
+      #     def resource
+      #       @location
+      #     end
+      #
+      #     def resource=(model)
+      #       @location = model
+      #     end
+      #   end
+      #
+      # @param actions [Array<:index, :show, :new, :create, :edit, :update, :destroy>]
+      # @param resources [Symbol, String]
+      # @return [void]
+      def garden_variety(*actions, resources: controller_name)
+        class_eval <<-CODE
+          private
+
+          def resource_class # optimized override
+            #{resources.to_s.classify}
+          end
+
+          def resources
+            @#{resources.to_s.underscore}
+          end
+
+          def resources=(models)
+            @#{resources.to_s.underscore} = models
+          end
+
+          def resource
+            @#{resources.to_s.underscore.singularize}
+          end
+
+          def resource=(model)
+            @#{resources.to_s.underscore.singularize} = model
+          end
+        CODE
+
+        action_modules = actions.empty? ?
+          ::GardenVariety::ACTION_MODULES.values :
+          ::GardenVariety::ACTION_MODULES.values_at(*actions)
+
+        action_modules.each{|m| include m }
+      end
+    end
+
+
+    private
+
+    # @!visibility public
+    # Returns the class of the resource corresponding to the controller
+    # name.
+    #
+    # @example
+    #   PostsController.new.resource_class  # == Post (class)
+    #
+    # @return [Class]
+    def resource_class
+      @resource_class ||= controller_name.classify.constantize
+    end
+
+    # @!visibility public
+    # Returns an ActiveRecord::Relation representing resource instances
+    # corresponding to the controller.  Designed for use in generic
+    # +index+ action methods.
+    #
+    # @example
+    #   class PostsController < ApplicationController
+    #     def index
+    #        @posts = list_resources.where(status: "published")
+    #     end
+    #   end
+    #
+    # @return [ActiveRecord::Relation]
+    def list_resources
+      resource_class.all
+    end
+
+    # @!visibility public
+    # Returns a model instance corresponding to the controller and the
+    # id parameter of the current request (i.e. +params[:id]+).
+    # Designed for use in generic +show+, +edit+, +update+, and
+    # +destroy+ action methods.
+    #
+    # @example
+    #   class PostsController < ApplicationController
+    #     def show
+    #        @post = find_resource
+    #     end
+    #   end
+    #
+    # @return [ActiveRecord::Base]
+    def find_resource
+      resource_class.find(params[:id])
+    end
+
+    # @!visibility public
+    # Returns a new model instance corresponding to the controller.
+    # Designed for use in generic +new+ and +create+ action methods.
+    #
+    # @example
+    #   class PostsController < ApplicationController
+    #     def new
+    #        @post = new_resource
+    #     end
+    #   end
+    #
+    # @return [ActiveRecord::Base]
+    def new_resource
+      resource_class.new
+    end
+
+    # @!visibility public
+    # Authorizes the given model for the current action via the model
+    # Pundit policy, and populates the model attributes with the current
+    # request params permitted by the model policy.  Returns the given
+    # model modified but not persisted.
+    #
+    # @example
+    #   class PostsController < ApplicationController
+    #     def create
+    #       @post = vest(Post.new)
+    #       if @post.save
+    #         redirect_to @post
+    #       else
+    #         render :new
+    #       end
+    #     end
+    #   end
+    #
+    # @param model [ActiveRecord::Base]
+    # @return [ActiveRecord::Base]
+    def vest(model)
+      authorize(model)
+      model.assign_attributes(permitted_attributes(model))
+      model
+    end
+  end
+end

data/lib/garden_variety/current_user_stub.rb

@@ -0,0 +1,8 @@
+module GardenVariety
+  # @!visibility private
+  module CurrentUserStub
+    def current_user
+      nil
+    end
+  end
+end

data/lib/garden_variety/railtie.rb

@@ -0,0 +1,29 @@
+require "rails/railtie"
+require "garden_variety/controller"
+require "garden_variety/current_user_stub"
+
+module GardenVariety
+  # @!visibility private
+  class Railtie < Rails::Railtie
+    # Render 404 on Pundit::NotAuthorizedError in production.  (Helpful
+    # error pages will still be shown in development.)  Code 404 is used
+    # because it is more discreet than 403, because it is explicitly
+    # allowed by RFC7231 (https://tools.ietf.org/html/rfc7231#section-6.5.3),
+    # and because Rails includes a default 404 page, but not a 403 page.
+    config.action_dispatch.rescue_responses["Pundit::NotAuthorizedError"] ||= :not_found
+
+    initializer "garden_variety.stub_current_user" do |app|
+      ActiveSupport.on_load :action_controller do
+        unless ActionController::Base.instance_methods.include?(:current_user)
+          ActionController::Base.send :include, GardenVariety::CurrentUserStub
+        end
+      end
+    end
+
+    initializer "garden_variety.extend_action_controller" do |app|
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.send :include, GardenVariety::Controller
+      end
+    end
+  end
+end

data/lib/garden_variety/version.rb

@@ -0,0 +1,3 @@
+module GardenVariety
+  VERSION = "1.0.0"
+end

data/lib/garden_variety.rb

@@ -0,0 +1,2 @@
+require "garden_variety/version"
+require "garden_variety/railtie"

data/lib/generators/garden/scaffold/scaffold_generator.rb

@@ -0,0 +1,39 @@
+require "rails/generators/base"
+
+# @!visibility private
+module Garden
+  module Generators
+    class ScaffoldGenerator < Rails::Generators::Base
+      argument :resource, type: :string
+
+      # NOTE: an appropriate default value for template_engine (e.g.
+      # :erb, or with the proper gem installed, :slim or :haml) is
+      # inherited from Rails::Generators::Base
+      class_option :template_engine
+
+      # override +initialize+ because it is the only way to reliably
+      # capture the raw input arguments in order to pass them on to
+      # `rails generate resource` (Thor neglects to provide an accessor,
+      # and ARGV is not populated during unit tests)
+      def initialize(raw_args, raw_opts, config)
+        @argv = raw_args + raw_opts
+        super
+      end
+
+      def generate_scaffolding
+        generate("resource", *@argv)
+        generate("#{options[:template_engine]}:scaffold", *@argv)
+      end
+
+      def inject_garden_variety_into_controller
+        inject_into_class("app/controllers/#{resource.tableize}_controller.rb",
+          "#{resource.tableize.camelize}Controller",
+          "  garden_variety\n")
+      end
+
+      def generate_pundit_policy
+        generate("pundit:policy", resource)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: garden_variety
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jonathan Hefner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.4
+- !ruby/object:Gem::Dependency
+  name: pundit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !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: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 
+email:
+- jonathan.hefner@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/garden_variety.rb
+- lib/garden_variety/actions.rb
+- lib/garden_variety/controller.rb
+- lib/garden_variety/current_user_stub.rb
+- lib/garden_variety/railtie.rb
+- lib/garden_variety/version.rb
+- lib/generators/garden/scaffold/scaffold_generator.rb
+homepage: https://github.com/jonathanhefner/garden_variety
+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.6.13
+signing_key: 
+specification_version: 4
+summary: Delightfully boring Rails controllers
+test_files: []