acls 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8368c41a5c809253d8edd299e4979988e71dc6f
+  data.tar.gz: 3add1931cdb2b571757adf3e7fa84ae223c38eea
+SHA512:
+  metadata.gz: af956f49b047caa81da85e43368f854dd316cf22bb8e930278226071a9e4b9230db0b431a735858f9626ee591a9b4b57bc7d7582b7cb8b70860ed7e90117dc84
+  data.tar.gz: 92564464ccf52966c6cd764ee13b426c946e11eb2f62e5b4b3f3ec21a9fff7f511b55317068703da641c17a8f162438cdf27e0130719808222e5128dd029bccb

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Tyler Margison
+
+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,98 @@
+# automatic code loading system (acls)
+
+[![Build Status](https://semaphoreci.com/api/v1/projects/80ef69fb-3dd1-499f-9e1c-acfa08d0a7d4/638892/badge.svg)](https://semaphoreci.com/kolorahl/acls)
+
+## What is it?
+
+The Automatic Code Loading System (ACLS) is a Ruby library intended to help
+speed up and simplify development time by allowing developers to define pathes
+and patterns of files that should be autoloaded when their application runs.
+
+## How does it work?
+
+Rails does something like this. In a Rails application you would change your
+autoloading paths as such:
+
+```ruby
+config.autoload_paths += ['lib', 'other/lib', 'etc'].map { |folder| "#{config.root}/#{folder}" }
+```
+
+Rails will then look for all Ruby files in those directory trees and load them
+for immediate use into your application. However, Rails does this in a very
+complex manner by taking over the flow for when a constant isn't found. ACLS
+does **not** do that. I have chosen a more straight-forward solution, which
+simply generates an `autoload` statement for all Ruby files in a set of paths.
+
+As an example, assume the following directory structure:
+
+```
+- lib
+| - one.rb
+| - two.rb
+| - sub
+| | - three.rb
+- other
+| - four.rb
+```
+
+Pass in the desired directory paths into the ACLS module:
+
+```ruby
+ACLS::Loader.auto(['lib', 'other'])
+```
+
+That one line with ACLS is equivalent to hand-writing the following Ruby code:
+
+```ruby
+autoload :One, 'lib/one.rb'
+autoload :Two, 'lib/two.rb'
+module Sub
+  autoload :Three, 'lib/sub/three.rb'
+end
+autoload :Four, 'other/four.rb'
+```
+
+## Using it
+
+The simplest way is to use:
+
+```ruby
+ACLS::Loader.auto(['path', 'to/one/or/more', 'directories'])
+```
+
+ACLS will automatically generate new module constants if it needs to. This
+method of autoloading, however, makes assumptions about the directory
+structure. The top-level directory is assumed to carry no namespace but every
+sub-directory under that *does* imply a namespace. To customize bits of the
+behavior, an options hash can be passed in as a second argument:
+
+```ruby
+ACLS::Loader.auto('lib', {root_ns: true})
+```
+
+Options available:
+
+- `root_ns`: When `true`, this will use the top-level directory name as the root
+  namespace for all files and folders in the tree. When a string is supplied,
+  this will use the string as the name of the root namespace. For all other
+  values, the root directory is not a namespace and everything falls under the
+  `Object` namespace.
+- `exclude`: Must be a collection of strings and/or regexps. For each string in
+  the collection, files are excluded from autoloading if they match the string
+  exactly. For each regexp in the collection, files are excluded from
+  autoloading if the path results in a successful match on the regexp.
+- `immediate`: Must be a collection of strings and/or regexps. Follows the same
+  conditional pattern as `exclude`, but on a match this will immediate load the
+  file via `load` instead of deferring it using `autoload`.
+
+## Feature List
+
+### Core
+
+- [X] Generate `autoload` statements based on a set of directory paths.
+
+### Options/Configuration
+
+- [X] Implement `root_ns`.
+- [ ] Implement `exclude`.
+- [ ] Implement `immediate`.

data/lib/acls.rb

@@ -0,0 +1,93 @@
+require 'active_support/inflector'
+require_relative './module'
+
+module ACLS
+  class Loader
+    class << self
+      # Use one or more paths to autoload a set of Ruby source files.
+      def auto(paths, opts={})
+        if paths.respond_to?(:each)
+          paths.each { |path| autoload_path(path, opts) }
+        else
+          autoload_path(paths, opts)
+        end
+      end
+
+      private
+
+      def get_root_ns(path, opts)
+        root_ns = opts[:root_ns]
+        root = Object
+        if root_ns.is_a?(TrueClass)
+          root = root.submodule(File.basename(path).camelize)
+        elsif root_ns.is_a?(String)
+          root_ns.split('::').each { |ns| root = root.submodule(ns) }
+        end
+        root
+      end
+
+      def autoload_path(path, opts)
+        if File.directory?(path)
+          root_ns = get_root_ns(path, opts)
+          autoload_magic(root_ns, path, opts)
+        else
+          raise Errno::ENOENT.new(path)
+        end
+      end
+
+      def autoload_magic(mod, path, opts)
+        # TODO: Add opts usage
+        Dir.entries(path).each do |entry|
+          next if entry[0] == '.'
+          full_path = "#{path}/#{entry}"
+          name = entry.sub(".rb", "").camelize
+          if File.directory?(full_path)
+            sub_mod = mod.submodule(name)
+            autoload_magic(sub_mod, full_path, opts)
+          else
+            autoload_for(mod, full_path, name)
+          end
+        end
+      end
+
+      def autoload_for(mod, path, name)
+        klass = guess_classname(path, name)
+        code = "autoload :#{klass}, \"#{path}\""
+        if mod.nil?
+          eval(code)
+        else
+          mod.module_eval(code)
+        end
+      end
+
+      def guess_classname(file, name)
+        process_classname_matches( scan_classnames(file), name )
+      end
+
+      def scan_classnames(file)
+        File.read(file).scan(/(class|module)\s+([^\n\r<]+)/)
+      end
+
+      def process_classname_matches(matches, name)
+        if match = best_classname_match(matches, name)
+          base_classname(match[1])
+        else
+          name
+        end
+      end
+
+      def best_classname_match(matches, name)
+        return nil unless matches
+        matches.drop_while { |match| !match_classname(match[1], name) }.first
+      end
+
+      def match_classname(match, name)
+        base_classname(match).downcase == name.downcase
+      end
+
+      def base_classname(name)
+        name.split("::").last
+      end
+    end
+  end
+end

data/lib/module.rb

@@ -0,0 +1,9 @@
+code = <<EOS
+def submodule(name)
+  const_get(name, false)
+rescue NameError
+  const_set(name, Module.new)
+end
+EOS
+
+Module.module_eval(code)

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: acls
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kolo Rahl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-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: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: ACLS is a library for autoloading Ruby source files in one or more directory
+  trees.
+email: kolorahl@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/acls.rb
+- lib/module.rb
+homepage: https://github.com/kolorahl/acls
+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.4.6
+signing_key: 
+specification_version: 4
+summary: ACLS - Automatic Code Loading System
+test_files: []
+has_rdoc: