acls 1.1.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b1e9054c2aa8a265732a826ab96128fe5101388
-  data.tar.gz: 51daeadc17700f03440fcdc417f56d90ab365897
+  metadata.gz: dbea83036ba56155987eaa3cdfa0955c95fd0410
+  data.tar.gz: cbe8a2759eebbbbd26be047e5c9bc5639f4539a3
 SHA512:
-  metadata.gz: bb760e38f2fab04f17a321c45439afefa8acf641c0f25888d8019e153e7ae277cd4bcc39d196c89a9ad12092127da22079b477debc41b1aa5f7a41e7f84bbcf1
-  data.tar.gz: 3f1d7c3c865a8161817e55855e76c50b03dd2f9933b7b9fa3f7c5c41106073582613565c69d848201dcead4ccfa3e2d0f7b11ebe2f68e8e2017a74a5c314754c
+  metadata.gz: 950a74f0011826e6447cc715dbead105c5817e19759eb00586a8f1a7f292d2b55bfe4ddfdab6c318ae9579813b7e8967b1756bc36481613a02788235c956cb69
+  data.tar.gz: 51905b9dbfcf6c444310a4d393f03da42842f6d0a48bbdd21a853228730f3f9a0d77d818217dd3403ebf00701d659751b3d138a20ef90d1f659beceda2324852

data/lib/acls.rb

@@ -1,4 +1,5 @@
 require 'active_support/inflector'
+require 'parser/current'
 
 module ACLS
   require_relative './acls/loader'

data/lib/acls/loader.rb

@@ -14,49 +14,43 @@ module ACLS
       private
 
       def build_trees(paths, opts)
-        if paths.respond_to?(:each)
-          paths.map { |path| build_tree(path, opts) }
-        else
-          [build_tree(paths, opts)]
-        end
-      end
-
-      def build_tree(path, opts)
-        Parser.parse(path)
+        paths = [paths] unless paths.respond_to?(:map)
+        paths.map { |path| Parser.parse(path) }
       end
 
       def autoload_statement(tree)
         "autoload :#{tree.name}, \"#{tree.source}\""
       end
 
-      def autoload_root(tree, opts)
-        root = Object
-        if opts[:root_ns].is_a?(TrueClass)
-          root = submodule(root, File.basename(tree.directory).camelize)
-        elsif opts[:root_ns].is_a?(String)
-          opts[:root_ns].split('::').each { |ns| root = submodule(root, ns) }
+      def autoload_tree(mod, tree, opts)
+        unless exclude?(tree, opts)
+          if tree.children.empty?
+            mod.module_eval(autoload_statement(tree))
+          else
+            mod = submodule(mod, tree.name)
+          end
+          tree.children.map { |child| autoload_tree(mod, child, opts) }
         end
-        root
       end
 
       def autoload_trees(trees, opts)
         trees.map do |tree|
-          root = autoload_root(tree, opts)
+          root = Object
           tree.children.map do |node|
             autoload_tree(root, node, opts)
           end
         end
       end
 
-      def autoload_tree(mod, tree, opts)
-        unless exclude?(mod, tree, opts)
-          if tree.source
-            mod.module_eval(autoload_statement(tree))
+      def exclude?(tree, opts)
+        opts[:exclude].each do |pattern|
+          if pattern.is_a?(String)
+            return true if pattern == File.basename(tree.path, ".rb")
           else
-            sub = submodule(mod, tree.name)
-            tree.children.map { |child| autoload_tree(sub, child, opts) }
+            return true if pattern.match(tree.path)
           end
         end
+        false
       end
 
       def submodule(parent, child)
@@ -65,17 +59,6 @@ module ACLS
         parent.const_set(child, Module.new)
       end
 
-      def exclude?(mod, tree, opts)
-        opts[:exclude].each do |pattern|
-          if pattern.is_a?(String)
-            return true if pattern == File.basename(tree.path, ".rb")
-          else
-            return true if pattern.match(tree.path)
-          end
-        end
-        false
-      end
-
     end
   end
 end

data/lib/acls/parser.rb

@@ -2,58 +2,77 @@ module ACLS
   class Parser
     class << self
 
-      def parse(base_dir, namespace=nil)
-        parse_tree(Tree.new(nil, namespace, base_dir))
+      # Given a base directory, parse all Ruby source files into a custom Tree
+      # representation.
+      def parse(base_dir)
+        parse_tree(Tree.new(nil, nil, base_dir), base_dir)
       end
 
       private
 
-      def parse_tree(parent)
-        Dir.entries(parent.directory).each do |entry|
-          next if entry[0] == '.'
-          full_path = "#{parent.directory}/#{entry}"
-          name = entry.sub(".rb", "").strip.camelize
-          if File.directory?(full_path)
-            child = parent.make_child(name, full_path)
-            parse_tree(child)
-          else
-            class_name = guess_classname(name, full_path)
-            parent.make_child(class_name, parent.directory, full_path)
-          end
-        end
-        parent
+      # Attempt to parse a collection of module/class names to determine a
+      # fully-qualified namespace for a source module/class.
+      def parse_names(node, parent, source)
+        return parent if node.nil?
+
+        parent = parse_names(node.children.first, parent, source)
+        parent.make_child(node.children.last, '', source)
+      end
+
+      # Parse an AST to get the top-most parent name and build a module/class
+      # chain from there.
+      def parse_parent(ast, parent, source)
+        name = ast.children.first
+        parse_names(name, parent, source)
       end
 
-      def guess_classname(name, file)
-        process_classname_matches( scan_classnames(file), name )
+      # Parse a module. Similar to parsing a class, except you continue to parse
+      # child nodes.
+      def parse_module(ast, parent, source)
+        parent = parse_parent(ast, parent, source)
+        ast.children[1..-1].map { |node| parse_ast(node, parent, source) }
       end
 
-      def scan_classnames(file)
-        contents = File.read(file)
-        contents.scrub! if (contents.respond_to?(:scrub!))
-        contents.scan(/(class|module)\s+([^\n\r<]+)/)
+      # Parse a class. Similar to parsing a module, except you do not parse any
+      # child nodes.
+      def parse_class(ast, parent, source)
+        parse_parent(ast, parent, source)
       end
 
-      def process_classname_matches(matches, name)
-        if match = best_classname_match(matches, name)
-          base_classname(match[1])
+      # Parse an AST Node.
+      def parse_ast(ast, parent, source)
+        return if ast.nil? || !ast.is_a?(::AST::Node)
+
+        if ast.type == :module
+          parse_module(ast, parent, source)
+        elsif ast.type == :class
+          parse_class(ast, parent, source)
         else
-          name
+          ast.children.each { |node| parse_ast(node, parent, source) }
         end
-      end
 
-      def best_classname_match(matches, name)
-        return nil unless matches
-        matches.drop_while { |match| !match_classname(match[1], name) }.first
+        parent
       end
 
-      def match_classname(match, name)
-        base_classname(match).downcase == name.downcase
+      # Convert a source file into an AST and parse it.
+      def parse_file(tree, file)
+        ast = ::Parser::CurrentRuby.parse(File.read(file))
+        parse_ast(ast, tree, file)
       end
 
-      def base_classname(name)
-        name.split("::").last.strip
+      def parse_tree(tree, directory)
+        Dir.entries(directory).each do |entry|
+          next if entry[0] == '.'
+          full_path = "#{directory}/#{entry}"
+          if File.directory?(full_path)
+            parse_tree(tree, full_path)
+          elsif entry.end_with?('.rb')
+            parse_file(tree, full_path)
+          end
+        end
+        tree
       end
+
     end
   end
 end

data/lib/acls/tree.rb

@@ -16,12 +16,29 @@ module ACLS
       child
     end
 
+    # If a source file is specified, returns the path to the source file.
     def path
       @source || @directory
     end
 
-    def to_s
-      "name: #{@name}, source: #{@source}, directory: #{@directory}, parent: #{@parent}, children: #{@children.length}"
+    # Find the first child with a given name, including the calling node in the
+    # search.
+    def find(name)
+      return self if @name == name
+      @children.find { |child| child.find(name) }
+    end
+
+    def to_s(level=0)
+      tab = '**' * 2 * level
+      <<EOS
+#{tab}     level: #{level}
+#{tab}      name: #{@name}
+#{tab}    source: #{@source}
+#{tab} directory: #{@directory}
+#{tab}  children => [
+#{@children.map { |child| child.to_s(level+1) }.join}
+#{tab}  ]
+EOS
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acls
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Kolo Rahl
@@ -30,6 +30,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.5
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement