drawers 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f965ef04831e18fcc88dbafe26068c72ac7e40cf
+  data.tar.gz: dea8bf6cdd778e52b2c89872cbbf1788ae3da39e
+SHA512:
+  metadata.gz: 11d4e29fdb9b5d62addbacc152bf8750c001e616a295a561e46a6067375fc7155a0a3ce76f66991c46255a128140f3d5ac7633d835980735b241d171df83653c
+  data.tar.gz: 94322be4dcd79e7285c20398228dc367edf8dcd26e9122681abb25e34525708533da8c56c51f8ef90fa3d9a576020b7b98f99dfc094654509ce074c8004642aa

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 L. Preston Sego III
+
+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,129 @@
+# drawers
+Group like-classes together. No more silos.
+
+[![Gem Version](https://badge.fury.io/rb/drawers.svg)](https://badge.fury.io/rb/drawers)
+[![Build Status](https://travis-ci.org/NullVoxPopuli/drawers.svg?branch=master)](https://travis-ci.org/NullVoxPopuli/drawers)
+[![Code Climate](https://codeclimate.com/repos/57dddb2c50dac40e6900197c/badges/73a0a0761e417c655b68/gpa.svg)](https://codeclimate.com/repos/57dddb2c50dac40e6900197c/feed)
+[![Test Coverage](https://codeclimate.com/repos/57dddb2c50dac40e6900197c/badges/73a0a0761e417c655b68/coverage.svg)](https://codeclimate.com/repos/57dddb2c50dac40e6900197c/coverage)
+[![Dependency Status](https://gemnasium.com/badges/github.com/NullVoxPopuli/drawers.svg)](https://gemnasium.com/github.com/NullVoxPopuli/drawers)
+
+
+## What is this about?
+
+With large rails application, the default architecture can result in a resource's related files being very spread out through the overall project structure. For example, lets say you have 50 controllers, serializers, policies, and operations. That's _four_ different top level folders that spread out all the related objects. It makes sense do it this way, as it makes rails' autoloading programmatically easy.
+
+This gem provides a way to re-structure your app so that like-objects are grouped together.
+
+All this gem does is add some new autoloading / path resolution logic. This gem does not provide any service/operation/policy/etc functionality.
+
+**All of this is optional, and can be slowly migrated to over time. Adding this gem does not force you to change your app.**
+
+### The new structure
+
+```ruby
+app/
+├── channels/
+├── models/
+│   ├── data/
+│   │   ├── post.rb
+│   │   └── comment.rb
+│   └── graph_data.rb
+├── jobs/
+├── mailers/
+│   └── notification_mailer.rb
+└── resources/
+    ├── posts/
+    │   ├── controller.rb  # or posts_controller.rb
+    │   ├── operations.rb  # or post_operations.rb
+    │   ├── policy.rb      # or post_policy.rb
+    │   └── serializer.rb  # or post_serializer.rb
+    └── comments/
+        ├── controller.rb
+        ├── serializer.rb
+        └── views/
+            ├── index.html.erb
+            └── create.html.erb
+
+```
+
+Does this new structure mean you have to change the class names of all your classes? Nope. In the above example file structure, `app/resources/posts/controller.rb` _still_ defines `class PostsController < ApplicationController`
+
+[Checkout the sample rails app in the tests directory.](https://github.com/NullVoxPopuli/drawers/tree/master/spec/support/rails_app/app)
+
+### The Convention
+
+Say, for example, you have _any_ class/module defined as:
+
+```ruby
+module Api                    # {namespace
+  module V3                   #  namespace}
+    module UserServices       # {resource_name}{resource_type}
+      module Authentication   # {class_path
+        class OAuth2          #  class_path/file_name}
+        end
+      end
+    end
+  end
+ end
+```
+
+As long as some part of the fully qualified class name (in this example: `Api::V3::UserServices::Authentication::OAuth2`) contains any of the [defined keywords](https://github.com/NullVoxPopuli/drawers/blob/master/lib/drawers/active_support/dependency_extensions.rb#L4), the file will be found at `app/resources/api/v3/users/services/authentication/oauth2.rb`.
+
+The pattern for this is: `app/resources/:namespace/:resource_name/:resource_type/:class_path` where:
+ - `:namespace` is the namespace/parents of the `UserService`
+ - `:resource_type` is a suffix that may be inferred by checking of the inclusion of the defined keywords (linked above)
+ - `:resource_name` is the same module/class as what the `resource_type` is derived from, sans the `resource_type`
+ - `:class_path` is the remaining namespaces and eventually the class that the target file defines.
+
+So... what if you have a set of classes that don't fit the pattern exactly? You can leave those files where they are currently, or move them to `app/resources`, if it makes sense to do so. Feel free to open an issue / PR if you feel the list of resource types needs updating.
+
+## Usage
+
+```ruby
+gem 'drawers'
+```
+
+Including the gem in your gemfile enables the new structure.
+
+### A note for ActiveModelSerializers
+
+ActiveModelSerializers, be default, does not consider your _controller's_ namespace when searching for searializers.
+
+To address that problem, you'll need to add this to the serializer lookup chain
+
+```ruby
+# config/initializers/active_model_serializers.rb
+ActiveModelSerializers.config.serializer_lookup_chain.unshift(
+  lambda do |resource_class, _, namespace|
+    "#{namespace.name}::#{resource_class.name}Serializer" if namespace
+  end
+)
+```
+Note: as of 2016-11-04, only [this branch of AMS](https://github.com/rails-api/active_model_serializers/pull/1757) supports a confnigurable lookup chain
+
+## Migrating
+
+Each part of your app can be migrated gradually (either manually or automatically).
+
+In order to automatically migrate resources, just run:
+
+```bash
+rake rmu:migrate_resource[Post]
+```
+
+This will move all unnamespaced classes that contain any of the [supported resource suffixes](https://github.com/NullVoxPopuli/drawers/blob/master/lib/drawers/active_support_extensions.rb#L4) to the `app/resources/posts` directory.
+
+## Configuration
+
+```ruby
+# (Rails.root)/config/initializers/drawers.rb
+Drawers.directory = 'pods'
+```
+
+Sets the folder for the new structure to be in the `app/pods` directory if you want the new structure separate from the main app files.
+
+## Contributing
+
+Feel free to open an issue, or fork and make a pull request.
+
+All discussion is welcome :-)

data/lib/drawers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module Drawers
+  require 'drawers/active_support/dependency_extensions'
+  require 'drawers/action_view/path_extensions'
+  require 'drawers/action_view/resource_resolver'
+  require 'drawers/resource_parts'
+
+  module_function
+
+  def directory=(dir)
+    @directory = dir
+  end
+
+  def directory
+    @directory || ''
+  end
+
+  require 'drawers/railtie'
+  ActiveSupport::Dependencies.extend Drawers::DependencyExtensions
+  ActionController::Base.extend Drawers::PathExtensions
+
+  if Rails.version > '5'
+    ActionController::API.extend Drawers::PathExtensions
+  end
+end

data/lib/drawers/action_view/path_extensions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Drawers
+  # prepend view paths, setting preferential lookup to the new
+  # RMU folders
+  #
+  # lookup pattern
+  #   resources/:namespace/:resource/views/:action/{.:locale,}{.:formats,}{+:variants,}{.:handlers,}
+  #   prefix = resources/:namespace/:resource/views/
+  #
+  # default lookup pattern (for reference (as of 5.0.0.1))
+  #   :prefix/:action{.:locale,}{.:formats,}{+:variants,}{.:handlers,}
+  #
+  # This module should only be used as class methods on the inheriting object
+  module PathExtensions
+    def local_prefixes
+      [_rmu_resource_path] + super
+    end
+
+    private
+
+    def _rmu_resource_path
+      [
+        _namespace,
+        _resource_name,
+        'views'
+      ].flatten.reject(&:blank?).map(&:underscore).join('/')
+    end
+
+    def _resource_name
+      controller_name
+    end
+
+    def _namespace
+      _resource_parts.namespace
+    end
+
+    def _resource_parts
+      @_resource_parts ||= Drawers::ResourceParts.call(name)
+    end
+  end
+end

data/lib/drawers/action_view/resource_resolver.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'action_view'
+
+module Drawers
+  class ResourceResolver < ::ActionView::OptimizedFileSystemResolver
+    def initialize
+      path = [
+        Rails.root,
+        'app',
+        Drawers.directory,
+        'resources'
+      ].reject(&:blank?).join('/')
+
+      super(path)
+      @path = path
+    end
+  end
+end

data/lib/drawers/active_support/dependency_extensions.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+module Drawers
+  module DependencyExtensions
+    RESOURCE_SUFFIX_NAMES = %w(
+      Controller
+      Serializer
+      Operations
+      Presenters
+      Policy
+      Policies
+      Services
+    ).freeze
+
+    # Join all the suffix names together with an "OR" operator
+    RESOURCE_SUFFIXES = /(#{RESOURCE_SUFFIX_NAMES.join('|')})/
+
+    # split on any of the resource suffixes OR the ruby namespace seperator
+    QUALIFIED_NAME_SPLIT = /::|#{RESOURCE_SUFFIXES}/
+
+    def load_from_path(file_path, qualified_name, from_mod, const_name)
+      expanded = File.expand_path(file_path)
+      expanded.sub!(/\.rb\z/, '')
+
+      if loading.include?(expanded)
+        raise "Circular dependency detected while autoloading constant #{qualified_name}"
+      else
+        require_or_load(expanded, qualified_name)
+        unless from_mod.const_defined?(const_name, false)
+          raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it"
+        end
+
+        return from_mod.const_get(const_name)
+      end
+    end
+
+    # A look for the possible places that various qualified names could be
+    #
+    # @note The Lookup Rules:
+    #   - all resources are plural
+    #   - file_names can either be named after the type or traditional ruby/rails nameing
+    #     i.e.: posts_controller.rb vs controller.rb
+    #   - regular namespacing still applies.
+    #     i.e: Api::V2::CategoriesController should be in
+    #          api/v2/categories/controller.rb
+    #
+    # @note The Pattern:
+    #  - namespace_a                        - api
+    #    - namespace_b                        - v2
+    #      - resource_name (plural)             - posts
+    #        - file_type.rb                       - controller.rb (or posts_controller.rb)
+    #                                             - operations.rb (or post_operations.rb)
+    #        - folder_type                        - operations/   (or post_operations/)
+    #          - related namespaced classes         - create.rb
+    #
+    # All examples assume default resource directory ("resources")
+    # and show the order of lookup
+    #
+    # @example Api::PostsController
+    #   Possible Locations
+    #    - api/posts/controller.rb
+    #    - api/posts/posts_controller.rb
+    #
+    # @example Api::PostSerializer
+    #   Possible Locations
+    #    - api/posts/serializer.rb
+    #    - api/posts/post_serializer.rb
+    #
+    # @example Api::PostOperations::Create
+    #   Possible Locations
+    #    - api/posts/operations/create.rb
+    #    - api/posts/post_operations/create.rb
+    #
+    # @example Api::V2::CategoriesController
+    #   Possible Locations
+    #    - api/v2/categories/controller.rb
+    #    - api/v2/categories/categories_controller.rb
+    #
+    # @param [String] qualified_name fully qualified class/module name to find the file location for
+    def resource_path_from_qualified_name(qualified_name)
+      namespace,
+      resource_name,
+      resource_type, named_resource_type,
+      class_path = ResourceParts.from_name(qualified_name)
+
+      # build all the possible places that this file could be
+      path_options = [
+
+        # api/v2/posts/operations/update
+        to_path(namespace, resource_name, resource_type, class_path),
+
+        # api/v2/posts/post_operations/update
+        to_path(namespace, resource_name, named_resource_type, class_path),
+
+        # api/v2/posts/posts_controller
+        to_path(namespace, resource_name, named_resource_type),
+
+        # api/v2/posts/controller
+        to_path(namespace, resource_name, resource_type)
+      ].uniq
+
+      file_path = ''
+      path_options.each do |path_option|
+        file_path = search_for_file(path_option)
+
+        break if file_path.present?
+      end
+
+      file_path
+    end
+
+    def to_path(*args)
+      args.flatten.reject(&:blank?).map(&:underscore).join('/')
+    end
+
+    # Load the constant named +const_name+ which is missing from +from_mod+. If
+    # it is not possible to load the constant into from_mod, try its parent
+    # module using +const_missing+.
+    def load_missing_constant(from_mod, const_name)
+      # always default to the actual implementation
+      super
+    rescue LoadError, NameError => e
+      load_missing_constant_error(from_mod, const_name, e)
+    end
+
+    # the heavy lifting of Drawers is just
+    # adding some additional pathfinding / constat lookup logic
+    # when the default (super) can't find what needs to be found
+    #
+    # @param [Class] from_mod - parent module / class that const_name may be a part of
+    # @param [Symbol] const_name - potential constant to lookup under from_mod
+    # @param [Exception] e - exception from previous error
+    def load_missing_constant_error(from_mod, const_name, e)
+      # examples
+      # - Api::PostsController
+      # - PostsController
+      qualified_name = qualified_name_for(from_mod, const_name)
+      file_path = resource_path_from_qualified_name(qualified_name)
+
+      begin
+        return load_from_path(file_path, qualified_name, from_mod, const_name) if file_path
+      rescue LoadError, NameError => e
+        # Recurse!
+        # not found, check the parent
+        at_the_top = from_mod.parent == from_mod
+        return load_missing_constant_error(from_mod.parent, const_name, e) unless at_the_top
+        raise e
+      end
+
+      name_error = NameError.new(e.message)
+      name_error.set_backtrace(caller.reject { |l| l.starts_with? __FILE__ })
+      raise name_error
+    end
+  end
+end

data/lib/drawers/railtie.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'rails/railtie'
+require 'action_controller'
+
+module Drawers
+  class Railtie < Rails::Railtie
+    railtie_name :drawers
+
+    rake_tasks do
+      load 'tasks/drawers.rake'
+    end
+
+    # for customizing where the new folder structure is
+    # by default, everything still resides in Rails.root/app
+    config_path = "#{Rails.root}/config/initializers/drawers"
+    config_exists = File.exist?(config_path)
+    require config_path if config_exists
+
+    # add folders to autoload paths
+    initializer 'activeservice.autoload', before: :set_autoload_paths do |app|
+      mu_dir = [
+        Rails.root,
+        'app',
+        Drawers.directory
+      ].reject(&:blank?).join('/')
+
+      # New location for ActiveRecord Models
+      app.config.autoload_paths << "#{mu_dir}/models/data"
+
+      # Resources
+      app.config.autoload_paths << "#{mu_dir}/resources/"
+    end
+
+    config.after_initialize do
+      ActionController::Base.prepend_view_path Drawers::ResourceResolver.new
+    end
+  end
+end

data/lib/drawers/resource_parts.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+module Drawers
+  class ResourceParts
+    RESOURCE_SUFFIX_NAMES = Drawers::DependencyExtensions::RESOURCE_SUFFIX_NAMES
+    QUALIFIED_NAME_SPLIT = Drawers::DependencyExtensions::QUALIFIED_NAME_SPLIT
+
+    attr_reader :namespace, :resource_name,
+      :resource_type, :named_resource_type,
+      :class_path
+
+    class << self
+      def from_name(name)
+        resource = call(name)
+
+        [
+          resource.namespace,
+          resource.resource_name,
+          resource.resource_type,
+          resource.named_resource_type,
+          resource.class_path
+        ]
+      end
+
+      def call(name)
+        resource = new(name)
+        resource.call
+        resource
+      end
+    end
+
+    def initialize(name)
+      @qualified_name = name
+    end
+
+    def call
+      # if this is not part of a resource, don't even bother
+      return unless index_of_resource_type
+
+      # Api, V2, Post, Operations, Update
+      # => Operations
+      @resource_type = qualified_parts[index_of_resource_type]
+
+      # Api, V2, Post, Operations, Update
+      # => Posts
+      #
+      # Posts, Controller
+      # => Posts
+      original_resource_name = qualified_parts[index_of_resource_type - 1]
+      @resource_name = original_resource_name.pluralize
+
+      # Posts_Controller
+      # Post_Operations
+      @named_resource_type = "#{original_resource_name}_#{@resource_type}"
+
+      # Api, V2, Post, Operations, Update
+      # => Api, V2
+      namespace_index = index_of_resource_type - 1
+      @namespace = namespace_index < 1 ? '' : qualified_parts.take(namespace_index)
+
+      # Api, V2, Post, Operations, Update
+      # => Update
+      class_index = index_of_resource_type + 1
+      @class_path = class_index < 1 ? '' : qualified_parts.drop(class_index)
+    end
+
+    private
+
+    # 1. break apart the qualified name into pieces that can easily be
+    #    manipulated
+    #
+    # Api::Posts
+    # => Api, Posts
+    #
+    # Api::PostOperations::Create
+    # => Api, Post, Operations, Create
+    #
+    # Api::PostsController
+    # => Api, Posts, Controller
+    #
+    # Api::V2::PostOperations::Update
+    # => Api, V2, Post, Operations, Update
+    def qualified_parts
+      @qualified_parts ||= @qualified_name.split(QUALIFIED_NAME_SPLIT).reject(&:blank?)
+    end
+
+    # based on the position of of the resource type name,
+    # anything to the left will be the namespace, and anything
+    # to the right will be the file path within the namespace
+    # (may be obvious, but basically, we're 'pivoting' on RESOURCE_SUFFIX_NAMES)
+    #
+    # Given: Api, V2, Post, Operations, Update
+    #                           ^ index_of_resource_type (3)
+    def index_of_resource_type
+      @index_of_resource_type ||= qualified_parts.index { |x| RESOURCE_SUFFIX_NAMES.include?(x) }
+    end
+  end
+end

data/lib/drawers/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Drawers
+  VERSION = '0.9.0'
+end

data/lib/tasks/drawers.rake

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+namespace :rmu do
+  config_path = "#{Rails.root}/config/initializers/drawers"
+  config_exists = File.exist?(config_path)
+  require config_path if config_exists
+
+  # @example
+  #  rake rmu:migrate_resource Post
+  # @example
+  #  rake rmu:migrate_resource Api::Event
+
+  desc 'Moves all files related to a resource to the RMU directory'
+  task :migrate_resource, [:klass_name] => :environment do |_t, args|
+    klass_name = args[:klass_name]
+
+    # Given klass_name,
+    # check known places where related files could be
+    singular = possible_classes(klass_name)
+    plural = possible_classes(klass_name, plural: true)
+
+    possibilities = singular + plural
+
+    possibilities.each do |possible_class|
+      klass = possible_class.safe_constantize
+
+      next unless klass
+
+      location = location_of(klass)
+
+      unless location
+        puts "#{klass.name} could not be found"
+        next
+      end
+
+      next if already_moved?(location)
+
+      destination = destination_for(location)
+      move_file(location, to: destination)
+    end
+  end
+
+  def destination_for(path)
+    # Rails.root does not include 'app/'
+    project_root = Rails.root.to_s
+    relative_path = path.sub(project_root, '')
+    relative_path_parts = relative_path.split('/').reject(&:blank?)
+
+    # remove app dir
+    # ["app", "serializers", "hosted_event_serializer.rb"]
+    # => ["serializers", "hosted_event_serializer.rb"]
+    relative_path_parts.shift
+
+    return if relative_path_parts.length < 2
+
+    # resource type (controller, serializer, etc)
+    # ["serializers", "hosted_event_serializer.rb"]
+    # => serializer
+    resource_type = relative_path_parts.shift.singularize
+
+    # ["hosted_event_serializer.rb"]
+    # => hosted_event_serializer.rb
+    file_name = relative_path_parts.pop
+
+    resource_name, extension = file_name.split("_#{resource_type}")
+
+    namespace = relative_path_parts.join('/')
+
+    destination = [
+      project_root,
+      'app',
+      Drawers.directory,
+      'resources',
+      namespace,
+      resource_name.pluralize,
+      resource_type
+    ].reject(&:blank?).join('/')
+
+    destination + extension
+  end
+
+  def move_file(from, to: nil)
+    puts "Moving #{from} to #{to}"
+    return unless to && from
+
+    matches = /.+\/(.+\.\w+)/.match(to)
+    file = matches[1]
+    path = to.sub(file, '')
+
+    unless File.directory?(path)
+      puts 'creating directory...'
+      FileUtils.mkdir_p(path)
+    end
+
+    FileUtils.move(from, to)
+  end
+
+  # See RESOURCE_SUFFIX_NAMES for total options
+  # PostSerializer
+  SINGULAR_RESOURCE_SUFFIXES = %w(
+    Serializer
+    Operations
+    Presenters
+    Policy
+    Policies
+  ).freeze
+
+  # PostsController
+  PLURAL_RESOURCE_SUFFIXES = %w(
+    Controller
+  ).freeze
+
+  def possible_classes(resource_name, plural: false)
+    klass_name = plural ? resource_name.pluralize : resource_name
+    suffixes = plural ? PLURAL_RESOURCE_SUFFIXES : SINGULAR_RESOURCE_SUFFIXES
+    suffixes.map { |suffix| "#{klass_name}#{suffix}" }
+  end
+
+  def location_of(klass)
+    # Flat default rails structure
+    guessed_path = guess_file_path(klass)
+    return guessed_path if File.exist?(guessed_path)
+
+    # Try to find the file based on method source location
+    # - will not work if a file doesn't define any methods
+    #   ( empty sub classes )
+    root = Rails.root.to_s
+    possible_paths = klass.instance_methods(false).map do |m|
+      klass.instance_method(m).source_location.first
+    end.uniq
+
+    possible_paths.select { |path| path.include?(root) }.first
+  end
+
+  def already_moved?(location)
+    location.include?("#{Drawers.directory}/resources")
+  end
+
+  def guess_file_path(klass)
+    underscored = klass.name.underscore
+    file_name = underscored + '.rb'
+    resource_type = underscored.split('_').last
+
+    guessed_path = File.join(
+      Rails.root,
+      'app',
+      resource_type.pluralize,
+      file_name
+    )
+
+    guessed_path
+  end
+end

metadata

@@ -0,0 +1,179 @@
+--- !ruby/object:Gem::Specification
+name: drawers
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- L. Preston Sego III
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-18 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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: awesome_print
+  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: pry-byebug
+  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: bundler
+  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: factory_girl
+  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: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Group like-classes together. No more silos.
+email: LPSego3+dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/drawers.rb
+- lib/drawers/action_view/path_extensions.rb
+- lib/drawers/action_view/resource_resolver.rb
+- lib/drawers/active_support/dependency_extensions.rb
+- lib/drawers/railtie.rb
+- lib/drawers/resource_parts.rb
+- lib/drawers/version.rb
+- lib/tasks/drawers.rake
+homepage: https://github.com/NullVoxPopuli/drawers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Drawers-0.9.0
+test_files: []