rails_module_unification 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d3872640062b5d3a147e451410b3a797b512773
-  data.tar.gz: 4c20943150ad3386792e31960cbb14326270b9b4
+  metadata.gz: 9ec1fa46bb3f2a6ff70fa6a4752fe649118ab97f
+  data.tar.gz: 62de027845335d0a7cf3e5d497b6b0f470cb340f
 SHA512:
-  metadata.gz: 4956f83bb5cea1d755c5d8ad13780fb5cab54d331ee59f4af8ab4bed20f7fcd08c0c51364824774a7567c5ddfe8cd0e16b18b635a022c41f9dae35c9e6a194f5
-  data.tar.gz: 0bf4109a287d04d4e7a62723aff8165895f55006613f223599c9082593516cb61a045c38a90ba74d7f2e8e8a3324229a8a7e8fcf11c46969765caaf20aa1e41e
+  metadata.gz: 9a192edd674eec00fd0fe2730616ed35f2d4c51479c6299b3749eed13a670027a55cc596f01ecc31b9645a1885161e9e4837af28cee97a5c0a1bdf03b31645de
+  data.tar.gz: cfe7e1e0987012999ce4309c016a772f4c8f0adb2aaf06c569c964a2f1cee772eb99dd303016c44aee28bcdf73ea67437ef8539f9dd34ada1b51d19c927e71ed

data/README.md

@@ -15,7 +15,6 @@ This gem provides a way to re-structure your app so that like-objects are groupe
 
 ### The new structure
 
-
 ```
 app/
 ├── channels/
@@ -38,6 +37,8 @@ app/
 
 ```
 
+[Checkout the sample rails app in the tests directory.](https://github.com/NullVoxPopuli/rails_module_unification/tree/master/spec/support/rails_app/app)
+
 ## Usage
 
 ```ruby
@@ -46,13 +47,26 @@ gem 'rails_module_unification'
 
 Including the gem in your gemfile enables the new structure.
 
+## 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/rails_module_unification/blob/master/lib/rails_module_unification/active_support_extensions.rb#L4) to the `app/resources/posts` directory.
+
 ## Configuration
 
 ```ruby
+# (Rails.root)/config/initializers/rails_module_unification.rb
 RailsModuleUnification.directory = 'pods'
 ```
 
-Sets the folder for the new structure to be in the `app/pods` directory so that you can gradually migrate to the new structure over time.
+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
 

data/lib/rails_module_unification/active_support_extensions.rb

@@ -1,7 +1,20 @@
 # frozen_string_literal: true
 module RailsModuleUnification
   module ActiveSupportExtensions
-    RESOURCE_SUFFIXES = /(Controller|Serializer|Operation|Policy)/
+    RESOURCE_SUFFIX_NAMES = %w(
+      Controller
+      Serializer
+      Operations
+      Presenters
+      Policy
+      Policies
+    ).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)
@@ -11,107 +24,179 @@ module RailsModuleUnification
         raise "Circular dependency detected while autoloading constant #{qualified_name}"
       else
         require_or_load(expanded, qualified_name)
-        raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it" unless from_mod.const_defined?(const_name, false)
+        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
 
-    def load_from_parent(from_mod, const_name)
-      # If our parents do not have a constant named +const_name+ then we are free
-      # to attempt to load upwards. If they do have such a constant, then this
-      # const_missing must be due to from_mod::const_name, which should not
-      # return constants from from_mod's parents.
-      parent = from_mod.parent
-      present_in_ancestry = (
-        parent &&
-        parent != from_mod &&
-        !from_mod.parents.any? { |p| p.const_defined?(const_name, false) }
-      )
-
-      # Since Ruby does not pass the nesting at the point the unknown
-      # constant triggered the callback we cannot fully emulate constant
-      # name lookup and need to make a trade-off: we are going to assume
-      # that the nesting in the body of Foo::Bar is [Foo::Bar, Foo] even
-      # though it might not be. Counterexamples are
+    # 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)
+      # 1. break apart the qualified name into pieces that can easily be
+      #    manipulated
       #
-      #   class Foo::Bar
-      #     Module.nesting # => [Foo::Bar]
-      #   end
+      # Api::Posts
+      # => Api, Posts
       #
-      # or
+      # Api::PostOperations::Create
+      # => Api, Post, Operations, Create
       #
-      #   module M::N
-      #     module S::T
-      #       Module.nesting # => [S::T, M::N]
-      #     end
-      #   end
+      # Api::PostsController
+      # => Api, Posts, Controller
       #
-      # for example.
-      return parent.const_missing(const_name) if present_in_ancestry
-    rescue NameError => e
-      raise unless e.missing_name? qualified_name_for(parent, const_name)
-    end
+      # Api::V2::PostOperations::Update
+      # => Api, V2, Post, Operations, Update
+      qualified_parts = qualified_name.split(QUALIFIED_NAME_SPLIT).reject(&:blank?)
+
+      # 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)
+      index_of_resource_type = qualified_parts.index { |x| RESOURCE_SUFFIX_NAMES.include?(x) }
 
-    def resource_path_from_qualified_name(qualified_name)
-      # examples
-      # - api/posts_controller
-      # - posts_controller
-      file_name = qualified_name.underscore.split('/').last
+      # if this is not part of a resource, don't even bother
+      return unless index_of_resource_type
 
-      # examples
-      # - controller
-      # - serializer
-      type_name = file_name.split('_').last
-
-      # folder/named_type.rb
-      # examples:
-      # - api/posts
-      # - posts
-      folder_name = qualified_name.split(RESOURCE_SUFFIXES).first.underscore.pluralize
-
-      # examples:
-      # - posts/posts_controller
-      folder_named_type = folder_name + '/' + file_name
-
-      # folder/type.rb
-      folder_type_name = folder_name + '/' + type_name
-
-      # without a folder / namespace?
-      # TODO: could this have undesired consequences?
-      file_path = search_for_file(file_name)
-      # the resource_name/controller.rb naming scheme
-      file_path ||= search_for_file(folder_type_name)
-      # the resource_name/resource_names_controller.rb naming scheme
-      file_path ||= search_for_file(folder_named_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)
+
+      # Finally,
+      # 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
+    rescue LoadError, NameError => e
+      load_missing_constant_error(from_mod, const_name, e)
+    end
 
+    # the heavy liftign of Rails Module Unification 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
-
+      qualified_name = qualified_name_for(from_mod, const_name)
       file_path = resource_path_from_qualified_name(qualified_name)
 
-      return load_from_path(file_path, qualified_name, from_mod, const_name) if file_path
-
-      # TODO: what is the situation in which this is needed?
-      mod = autoload_module!(from_mod, const_name, qualified_name, file_name)
-      return mod if mod
-
-      from_parent = load_from_parent(from_mod, const_name)
-      return from_parent if from_parent
+      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("uninitialized constant #{qualified_name}", const_name)
+      name_error = NameError.new(e.message)
       name_error.set_backtrace(caller.reject { |l| l.starts_with? __FILE__ })
       raise name_error
     end

data/lib/rails_module_unification/railtie.rb

@@ -3,8 +3,17 @@ require 'rails/railtie'
 
 module RailsModuleUnification
   class Railtie < Rails::Railtie
+    railtie_name :rails_module_unification
+
+    rake_tasks do
+      load 'tasks/rails_module_unification.rake'
+    end
+
+    config_path = "#{Rails.root}/config/initializers/rails_module_unification"
+    config_exists = File.exist?(config_path)
+    require config_path if config_exists
+
     initializer 'activeservice.autoload', before: :set_autoload_paths do |app|
-      # TODO: make the module unification root directory configurable
       mu_dir = "#{Rails.root}/app/#{RailsModuleUnification.directory}"
 
       # Data

data/lib/rails_module_unification/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module RailsModuleUnification
-  VERSION = '0.5.3'.freeze
+  VERSION = '0.6.0'.freeze
 end

data/lib/tasks/rails_module_unification.rake

@@ -0,0 +1,152 @@
+namespace :rmu do
+  config_path = "#{Rails.root}/config/initializers/rails_module_unification"
+  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',
+      RailsModuleUnification.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
+  )
+
+  # PostsController
+  PLURAL_RESOURCE_SUFFIXES = %w(
+    Controller
+  )
+
+  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?("#{RailsModuleUnification.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

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_module_unification
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - L. Preston Sego III
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-18 00:00:00.000000000 Z
+date: 2016-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -162,6 +162,7 @@ files:
 - lib/rails_module_unification/active_support_extensions.rb
 - lib/rails_module_unification/railtie.rb
 - lib/rails_module_unification/version.rb
+- lib/tasks/rails_module_unification.rake
 homepage: https://github.com/NullVoxPopuli/rails_module_unification
 licenses:
 - MIT
@@ -182,8 +183,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
-summary: RailsModuleUnification-0.5.3
+summary: RailsModuleUnification-0.6.0
 test_files: []