term_utils 0.3.2 → 0.4.0

data/lib/term_utils/ff.rb

@@ -1,4 +1,6 @@
-# Copyright (C) 2019 Thomas Baron
+# frozen-string-literal: true
+
+# Copyright (C) 2020 Thomas Baron
 #
 # This file is part of term_utils.
 #
@@ -13,6 +15,13 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with term_utils.  If not, see <https://www.gnu.org/licenses/>.
+
+module TermUtils
+  # Provides a way to find files.
+  module FF
+  end
+end
+
 require 'term_utils/ff/config'
-require 'term_utils/ff/cursor'
+require 'term_utils/ff/entry'
 require 'term_utils/ff/query'

data/lib/term_utils/ff/config.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
-#
-# Copyright (C) 2019 Thomas Baron
+
+# Copyright (C) 2020 Thomas Baron
 #
 # This file is part of term_utils.
 #
@@ -15,25 +15,37 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with term_utils.  If not, see <https://www.gnu.org/licenses/>.
+
 module TermUtils
-  # The ff module provides a way to find files.
   module FF
     # Represents a query configuration.
     class Config
       # @return [Array<Regexp>]
       attr_accessor :ignore_list
-      # @return [Integer]
+      # @return [Integer, nil]
       attr_accessor :min_depth
-      # @return [Integer]
+      # @return [Integer, nil]
       attr_accessor :max_depth
-      # @return [Boolean]
-      attr_accessor :sorted
+      # @return [Symbol, nil] Either `:forward`, `:reverse` or `nil` (default).
+      attr_accessor :sorting_mode
+      # @return [Proc, nil]
+      attr_accessor :sorting_compare
+
+      # Constructs a new Config.
       def initialize
         @ignore_list = []
         @min_depth = nil
         @max_depth = nil
-        @sorted = false
+        @sorting_mode = nil
+        @sorting_compare = nil
+      end
+
+      # Returns whether the search is ordered.
+      # @return [Boolean]
+      def sorted?
+        (@sorting_mode == :forward) || (@sorting_mode == :reverse)
       end
+
       def initialize_copy(other)
         @ignore_list = other.ignore_list.dup
         super

data/lib/term_utils/{ap/no_such_value_error.rb → ff/entry.rb}

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
-#
-# Copyright (C) 2019 Thomas Baron
+
+# Copyright (C) 2020 Thomas Baron
 #
 # This file is part of term_utils.
 #
@@ -15,12 +15,30 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with term_utils.  If not, see <https://www.gnu.org/licenses/>.
+
 module TermUtils
-  module AP
-    # No such value error.
-    class NoSuchValueError < StandardError
-      def initialize(msg)
-        super
+  module FF
+    # Represents an Entry of a Query result.
+    class Entry
+      # @return [Integer]
+      attr_accessor :index
+      # @return [String]
+      attr_accessor :name
+      # @return [Array<String>]
+      attr_accessor :relative_path_comps
+      # @return [String]
+      attr_accessor :path
+
+      def initialize
+        @index = nil
+        @name = nil
+        @relative_path_comps = nil
+        @path = nil
+      end
+
+      # @return [Integer]
+      def depth
+        @relative_path_comps.length
       end
     end
   end

data/lib/term_utils/ff/query.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
-#
-# Copyright (C) 2019 Thomas Baron
+
+# Copyright (C) 2020 Thomas Baron
 #
 # This file is part of term_utils.
 #
@@ -15,51 +15,130 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with term_utils.  If not, see <https://www.gnu.org/licenses/>.
+
 module TermUtils
-  # The ff module provides a way to find files.
   module FF
+    # Query search context.
+    Context = Struct.new('Context', :config, :base_path, :block, :index_seq, :result)
     # Represents a file system query.
     class Query
+      # Constructs a new Query.
       def initialize
         @config = TermUtils::FF::Config.new
       end
+
       def initialize_copy(other)
         @config = other.config.dup
         super
       end
+
       # Adds a Regexp to ignore.
       # @param regexp [Regexp]
-      # @return [TermUtils::FF::Query]
+      # @return [Query]
       def ignore(regexp)
         @config.ignore_list << regexp
         self
       end
+
       # Sets a minimum depth.
       # @param depth [Integer]
-      # @return [TermUtils::FF::Query]
+      # @return [Query]
       def min_depth(depth)
         @config.min_depth = depth
         self
       end
+
       # Sets a maximum depth.
       # @param depth [Integer]
-      # @return [TermUtils::FF::Query]
+      # @return [Query]
       def max_depth(depth)
         @config.max_depth = depth
         self
       end
-      # Sets whether results shall be sorted.
-      # @param sorted [Boolean]
-      # @return [TermUtils::FF::Query]
-      def sort(sorted = true)
-        @config.sorted = sorted
+
+      # Sets the sorting mode.
+      # @param mode [Symbol] Either `:forward`, `:reverse` or `nil` (default).
+      # @return [Query]
+      def sort(mode = :forward, &block)
+        @config.sorting_mode = mode
+        @config.sorting_compare = block
         self
       end
+
       # Executes this one.
       # @param path [String]
-      # @return [TermUtils::FF::Cursor]
-      def exec(path)
-        TermUtils::FF::Cursor.new(@config.dup, path).bootstrap
+      # @return [Array<Entry>]
+      def exec(path, &block)
+        ctx = Context.new
+        ctx.config = @config.dup
+        ctx.config.min_depth = 0 if ctx.config.min_depth.nil?
+        ctx.base_path = path
+        ctx.block = block
+        ctx.index_seq = 0
+        ctx.result = []
+        first_entry = TermUtils::FF::Entry.new
+        first_entry.name = path
+        first_entry.relative_path_comps = []
+        first_entry.path = path
+        if ctx.config.min_depth == 0
+          first_entry.index = ctx.index_seq
+          ctx.index_seq += 1
+          ctx.block.call(first_entry) if ctx.block
+          ctx.result << first_entry
+        end
+        if File.directory?(first_entry.path) && (ctx.config.max_depth.nil? || ctx.config.max_depth > 0)
+          TermUtils::FF::Query.search(ctx, first_entry)
+        end
+        ctx.result
+      end
+
+      # Searches a directory.
+      # @param ctx [Context]
+      # @param parent_entry [entry]
+      # @return [nil]
+      def self.search(ctx, parent_entry)
+        entries = Dir.entries(parent_entry.path)
+        unless ctx.config.sorting_mode.nil?
+          if ctx.config.sorting_compare.nil?
+            entries.sort!
+          else
+            entries.sort!(&ctx.config.sorting_compare)
+          end
+          if ctx.config.sorting_mode == :reverse
+            entries.reverse!
+          end
+        end
+        entries.each do |name|
+          next if %w[. ..].include? name
+          next unless accept_entry_name?(ctx, name)
+
+          new_entry = TermUtils::FF::Entry.new
+          new_entry.name = name
+          new_entry.relative_path_comps = parent_entry.relative_path_comps.dup.push(name)
+          new_entry.path = "#{ctx.base_path}/#{new_entry.relative_path_comps.join('/')}"
+          if ctx.config.min_depth <= new_entry.depth
+            new_entry.index = ctx.index_seq
+            ctx.index_seq += 1
+            ctx.block.call(new_entry) if ctx.block
+            ctx.result << new_entry
+          end
+          if File.directory?(new_entry.path) && (ctx.config.max_depth.nil? || ctx.config.max_depth > new_entry.depth)
+            TermUtils::FF::Query.search(ctx, new_entry)
+          end
+        end
+      end
+
+      # Tests whether a given entry should be accepted.
+      # @param ctx [Context]
+      # @param name [String]
+      # @return [Boolean]
+      def self.accept_entry_name?(ctx, name)
+        ctx.config.ignore_list.each do |i|
+          if i.match? name
+            return false
+          end
+        end
+        true
       end
     end
   end

data/lib/term_utils/property_tree_node.rb

@@ -1,4 +1,6 @@
-# Copyright (C) 2019 Thomas Baron
+# frozen-string-literal: true
+
+# Copyright (C) 2020 Thomas Baron
 #
 # This file is part of term_utils.
 #
@@ -13,19 +15,21 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with term_utils.  If not, see <https://www.gnu.org/licenses/>.
+
 module TermUtils
   # Represents a general-purpose tree node that holds a key-value pair.
   class PropertyTreeNode
-    # @return [TermUtils::PropertyTreeNode]
+    # @return [PropertyTreeNode]
     attr_accessor :parent_node
-    # @return [Array<TermUtils::PropertyTreeNode>]
+    # @return [Array<PropertyTreeNode>]
     attr_accessor :child_nodes
     # @return [Object]
     attr_accessor :key
     # @return [Object]
     attr_accessor :value
-    # Creates a new node.
-    # @param opts [Hash<Symbol, Object>]
+
+    # Creates a new PropertyTreeNode.
+    # @param opts [Hash]
     # option opts [Object] :key
     # option opts [Object] :value
     def initialize(opts = {}, &block)
@@ -35,6 +39,7 @@ module TermUtils
       @value = opts.fetch(:value, nil)
       block.call(self) if block
     end
+
     # For dup method.
     def initialize_dup(other)
       @parent_node = nil
@@ -48,27 +53,33 @@ module TermUtils
       end
       super
     end
+
     # Tests whether this one is the head of the tree (i.e. has no parent).
     # @return [Boolean]
     def head?
       @parent_node == nil
     end
+
     # Tests whether this one is a leaf of the tree (i.e. has no child).
     # @return [Boolean]
     def leaf?
       @child_nodes == nil
     end
+
     # Returns the child node identified by a given key.
     # @param key [Object]
-    # @return [TermUtils::PropertyTreeNode, nil]
+    # @return [PropertyTreeNode, nil]
     def child_node(key)
       if @child_nodes
         @child_nodes.find { |n| n.key == key }
       end
     end
+
     # Creates a new node and adds it as a child.
-    # @param opts [Hash<Symbol,Object>] key value
-    # @return [TermUtils::PropertyTreeNode]
+    # @param opts [Hash]
+    # @option opts [Object] :key
+    # @option opts [Object] :value
+    # @return [PropertyTreeNode]
     def define_node(opts = {}, &block)
       new_node = TermUtils::PropertyTreeNode.new(opts)
       new_node.parent_node = self
@@ -77,6 +88,7 @@ module TermUtils
       block.call(new_node) if block
       new_node
     end
+
     # Builds the path of keys.
     # @return [Array<Object>]
     def path
@@ -84,12 +96,15 @@ module TermUtils
       p << @key if @key
       p
     end
+
     # Iterates over every node.
-    # @param opts [Hash<Symbol,Object>] `:path`, `:leaf_only`
+    # @param opts [Hash]
+    # @option opts [Array] :path
+    # @option opts [Boolean] :leaf_only
     # @return [nil]
     def each_node(opts = {}, &block)
       rpath = nil
-      if opts.has_key? :path
+      if opts.key? :path
         rpath = opts[:path].dup
       end
       dive = true
@@ -105,15 +120,15 @@ module TermUtils
             hide = true
           end
         end
-        unless hide or (opts[:leaf_only] and @child_nodes)
-          if opts.has_key? :block
+        unless hide || (opts[:leaf_only] && @child_nodes)
+          if opts.key? :block
             opts[:block].call(self)
           elsif block
             block.call(self)
           end
         end
       end # if @key
-      if dive and @child_nodes
+      if dive && @child_nodes
         ropts = opts.dup
         if rpath
           if rpath.empty?
@@ -131,9 +146,12 @@ module TermUtils
       end
       nil
     end
+
     # Collects nodes.
-    # @param opts [Hash<Symbol,Object>] `:path`, `:leaf_only`
-    # @return [Array<TermUtils::PropertyTreeNode>]
+    # @param opts [Hash]
+    # @option opts [Array] :path
+    # @option opts [Boolean] :leaf_only
+    # @return [Array<PropertyTreeNode>]
     def collect_nodes(opts = {})
       nodes = []
       each_node(opts) do |n|
@@ -141,8 +159,11 @@ module TermUtils
       end
       nodes
     end
+
     # Collects node paths.
-    # @param opts [Hash<Symbol,Object>] `:path`, `:leaf_only`
+    # @param opts [Hash]
+    # @option opts [Array] :path
+    # @option opts [Boolean] :leaf_only
     # @return [Array<Array<Object>>]
     def collect_paths(opts = {})
       paths = []
@@ -151,8 +172,11 @@ module TermUtils
       end
       paths
     end
+
     # Collect node values.
-    # @param opts [Hash<Symbol,Object>] `:path`, `:leaf_only`
+    # @param opts [Hash]
+    # @option opts [Array] :path
+    # @option opts [Boolean] :leaf_only
     # @return [Array<Object>]
     def collect_values(opts = {})
       vals = []
@@ -161,23 +185,26 @@ module TermUtils
       end
       vals
     end
+
     # Finds the node identified by a given path of keys.
     # @param path [Array<Object>]
-    # @return [TermUtils::PropertyTreeNode]
+    # @return [PropertyTreeNode]
     def find_node(path)
       catch :found do
-        each_node(:path => path) do |n|
+        each_node(path: path) do |n|
           throw :found, n
         end
         nil
       end
     end
+
     # Tests whether the node identified by a given path of keys exists.
     # @param path [Array<Object>]
     # @return [Boolean]
     def node_exists?(path)
       find_node(path) != nil
     end
+
     # Evaluates the total number of nodes in the tree represented by this one.
     # @param path [Array<Object>]
     # @return [Integer]
@@ -187,6 +214,7 @@ module TermUtils
         node.child_nodes ? node.child_nodes.length : 0
       end
     end
+
     # Finds the node identified by a given path of keys and returns its value.
     # @param path [Array<Object>]
     # @return [Object]