term_utils 0.1.1 → 0.4.0

data/lib/term_utils/ap/syntax.rb

@@ -0,0 +1,96 @@
+# frozen-string-literal: true
+
+# Copyright (C) 2020 Thomas Baron
+#
+# This file is part of term_utils.
+#
+# term_utils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# term_utils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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
+    # Represents the argument list syntax. It holds a list of parameters.
+    class Syntax
+      # @return [Array<Parameter>]
+      attr_accessor :parameters
+
+      # Constructs a new Syntax.
+      def initialize
+        @parameters = []
+      end
+
+      # For dup method.
+      def initialize_dup(other)
+        super(other)
+        @parameters = other.parameters.map(&:dup) if other.parameters
+      end
+
+      # Finalizes this one. Internal use.
+      # @return [nil]
+      # @raise [SyntaxError]
+      def finalize!(opts = {})
+        opts[:anonymous] = 0 unless opts.key? :anonymous
+        opts[:flag_labels] = []
+        @parameters.each { |p| p.finalize!(opts) }
+        nil
+      end
+
+      # Creates and adds a new Parameter.
+      # @param id [Symbol, nil]
+      # @param opts [Hash]
+      # @option opts [Symbol] :id
+      # @option opts [Integer] :min_occurs
+      # @option opts [Integer] :max_occurs
+      # @return [Parameter]
+      def define_parameter(id = nil, opts = {}, &block)
+        if id
+          param = @parameters.find { |p| p.id == id }
+          if param
+            block.call(param) if block
+            return param
+          end
+
+          opts[:id] = id
+        end
+        new_parameter = TermUtils::AP::Parameter.new(opts)
+        @parameters << new_parameter
+        block.call(new_parameter) if block
+        new_parameter
+      end
+
+      # Fetches all flagged parameters and unflagged parameters.
+      # @return [Array]
+      def fetch_parameters
+        unflagged_params = []
+        flagged_params = {}
+        shortcut_flags = {}
+        @parameters.each do |p|
+          if p.flagged?
+            # Flagged
+            p.flags.each do |f|
+              flagged_params[f.label] = p
+              if f.long?
+                shortcut_flags["#{f.label}="] = f
+              else
+                shortcut_flags[f.label] = f
+              end
+            end
+          else
+            # Unflagged
+            unflagged_params << p
+          end
+        end
+        [unflagged_params, flagged_params, shortcut_flags]
+      end
+    end
+  end
+end

data/lib/term_utils/ff.rb

@@ -0,0 +1,27 @@
+# frozen-string-literal: true
+
+# Copyright (C) 2020 Thomas Baron
+#
+# This file is part of term_utils.
+#
+# term_utils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# term_utils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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/entry'
+require 'term_utils/ff/query'

data/lib/term_utils/ff/config.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+# Copyright (C) 2020 Thomas Baron
+#
+# This file is part of term_utils.
+#
+# term_utils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# term_utils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 FF
+    # Represents a query configuration.
+    class Config
+      # @return [Array<Regexp>]
+      attr_accessor :ignore_list
+      # @return [Integer, nil]
+      attr_accessor :min_depth
+      # @return [Integer, nil]
+      attr_accessor :max_depth
+      # @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
+        @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
+      end
+    end
+  end
+end

data/lib/term_utils/ff/entry.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+
+# Copyright (C) 2020 Thomas Baron
+#
+# This file is part of term_utils.
+#
+# term_utils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# term_utils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 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
+end

data/lib/term_utils/ff/query.rb

@@ -0,0 +1,145 @@
+# frozen-string-literal: true
+
+# Copyright (C) 2020 Thomas Baron
+#
+# This file is part of term_utils.
+#
+# term_utils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# term_utils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 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 [Query]
+      def ignore(regexp)
+        @config.ignore_list << regexp
+        self
+      end
+
+      # Sets a minimum depth.
+      # @param depth [Integer]
+      # @return [Query]
+      def min_depth(depth)
+        @config.min_depth = depth
+        self
+      end
+
+      # Sets a maximum depth.
+      # @param depth [Integer]
+      # @return [Query]
+      def max_depth(depth)
+        @config.max_depth = depth
+        self
+      end
+
+      # 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 [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
+end

data/lib/term_utils/property_tree_node.rb

@@ -0,0 +1,228 @@
+# frozen-string-literal: true
+
+# Copyright (C) 2020 Thomas Baron
+#
+# This file is part of term_utils.
+#
+# term_utils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# term_utils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 [PropertyTreeNode]
+    attr_accessor :parent_node
+    # @return [Array<PropertyTreeNode>]
+    attr_accessor :child_nodes
+    # @return [Object]
+    attr_accessor :key
+    # @return [Object]
+    attr_accessor :value
+
+    # Creates a new PropertyTreeNode.
+    # @param opts [Hash]
+    # option opts [Object] :key
+    # option opts [Object] :value
+    def initialize(opts = {}, &block)
+      @parent_node = nil
+      @child_nodes = nil
+      @key = opts.fetch(:key, nil)
+      @value = opts.fetch(:value, nil)
+      block.call(self) if block
+    end
+
+    # For dup method.
+    def initialize_dup(other)
+      @parent_node = nil
+      if other.child_nodes
+        @child_nodes = []
+        other.child_nodes.each do |n|
+          new_node = n.dup
+          new_node.parent_node = self
+          @child_nodes << new_node
+        end
+      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 [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]
+    # @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
+      @child_nodes = [] unless @child_nodes
+      @child_nodes << new_node
+      block.call(new_node) if block
+      new_node
+    end
+
+    # Builds the path of keys.
+    # @return [Array<Object>]
+    def path
+      p = @parent_node ? @parent_node.path : []
+      p << @key if @key
+      p
+    end
+
+    # Iterates over every node.
+    # @param opts [Hash]
+    # @option opts [Array] :path
+    # @option opts [Boolean] :leaf_only
+    # @return [nil]
+    def each_node(opts = {}, &block)
+      rpath = nil
+      if opts.key? :path
+        rpath = opts[:path].dup
+      end
+      dive = true
+      if @key
+        hide = false
+        if rpath
+          if rpath.shift == @key
+            unless rpath.empty?
+              hide = true
+            end
+          else
+            dive = false
+            hide = true
+          end
+        end
+        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 && @child_nodes
+        ropts = opts.dup
+        if rpath
+          if rpath.empty?
+            ropts.delete :path
+          else
+            ropts[:path] = rpath
+          end
+        end
+        if block
+          ropts[:block] = block
+        end
+        @child_nodes.each do |n|
+          n.each_node(ropts)
+        end
+      end
+      nil
+    end
+
+    # Collects nodes.
+    # @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|
+        nodes << n
+      end
+      nodes
+    end
+
+    # Collects node paths.
+    # @param opts [Hash]
+    # @option opts [Array] :path
+    # @option opts [Boolean] :leaf_only
+    # @return [Array<Array<Object>>]
+    def collect_paths(opts = {})
+      paths = []
+      each_node(opts) do |n|
+        paths << n.path
+      end
+      paths
+    end
+
+    # Collect node values.
+    # @param opts [Hash]
+    # @option opts [Array] :path
+    # @option opts [Boolean] :leaf_only
+    # @return [Array<Object>]
+    def collect_values(opts = {})
+      vals = []
+      each_node(opts) do |n|
+        vals << n.value if n.value
+      end
+      vals
+    end
+
+    # Finds the node identified by a given path of keys.
+    # @param path [Array<Object>]
+    # @return [PropertyTreeNode]
+    def find_node(path)
+      catch :found do
+        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]
+    def eval_child_count(path)
+      node = find_node(path)
+      if node
+        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]
+    def find_node_value(path)
+      node = find_node(path)
+      if node
+        node.value
+      end
+    end
+  end
+end