trees 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc7886d327dd2a8f6d2a3833a08ba2b555b198d441c0348e276670514fde2b5f
-  data.tar.gz: a7a6a657bb62fa25936a50b4c991e260e0d1daf6b421c063b4184a088f89b57a
+  metadata.gz: 1ac49d1c7aaa58a8ff86b29db7c2b7915c470094de6b3c1af4fbd4ad45adc597
+  data.tar.gz: 4a02b57c93cec8b8b42c36f39b158d0cca4c6d2a907b2c72bfdbfb38c5b57a74
 SHA512:
-  metadata.gz: ddd1461e661cfc499e54d516f801ececa8fafbfd3613f9bbb119d2ee14b62701d6b3e05784f3539619cbcd75adbb3476209416e2e3fa64b2a09a42342f23e7c4
-  data.tar.gz: af7bb3374418c5b39151076c07fceb1c38d58bf44deb890bfffb4d88c5a0a2218477e40e830e29418fecb374bc6804c3c52e722ed575260be99e31e2a0928674
+  metadata.gz: f37c39226cd76bfc232ef4933aa6221b8bf6069c90a0af11e2160dcbe62be6ba2072b63f7562c0b63e44f69eed949e380a59b58302cc52cbb2fa8d39e36429f7
+  data.tar.gz: 0b5c295977cb0b50c80c1c0fcbd271a5923f80943cc08efc0ded1ce333008723c21532c33c8e376adf6de5d718610b26b79f23d7fa3b0ee4b84d349fc0f0cd61

data/lib/line.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'low_type'
+
+module Trees
+  class Line
+    include LowType
+
+    attr_reader :path, :params
+    attr_accessor :summary, :execute
+
+    def initialize(path: String, params: {})
+      @path = path
+      @params = params
+
+      @summary = nil
+      @execute = nil
+    end
+  end
+end

data/lib/trees.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'line'
+require_relative 'trie'
+
+module Trees
+  attr_reader :lines, :trie
+
+  def line(path, &block)
+    current_path << path
+    @current_line = Line.new(path: current_path.join, params: block.parameters.to_h)
+
+    lines[current_path.join] = @current_line
+    trie.merge(line: @current_line)
+
+    block.call if block_given?
+
+    current_path.pop
+  end
+
+  def summary(&block)
+    @current_line.summary = block
+  end
+
+  def execute(&block)
+    @current_line.execute = block
+  end
+
+  def run(tokens)
+    results = trie.match(tokens:)
+
+    execute_block(results:)
+  end
+
+  private
+
+  def execute_block(results:)
+    while results.count > 0
+      result = results.pop
+
+      if result.line.execute
+        result.line.params.values.each do |param|
+          result.line.execute.binding.local_variable_set(param, result.params[param])
+        end
+
+        result.line.execute.call
+
+        return true
+      end
+    end
+
+    false
+  end  
+
+  def current_path
+    @current_path ||= []
+  end
+
+  def lines
+    @lines ||= {}
+  end
+
+  def trie
+    @trie ||= Trie.new
+  end
+end

data/lib/trie.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative 'line'
+require_relative 'trie_node'
+
+module Trees
+  class Trie
+    include LowType
+
+    PARAM_DELIMITERS = [' ', ':'].freeze
+
+    attr_reader :root_node
+
+    Result = Data.define(:line, :params)
+
+    class DuplicatePathError < StandardError; end
+
+    def initialize
+      @root_node = TrieNode.new
+    end
+
+    def merge(line:, current_node: @root_node)
+      @current_index = 0
+      path = line.path
+
+      while @current_index < path.length
+        key = path[@current_index]
+
+        @current_index += 1
+
+        # Sometimes the key is an entire variable name.
+        key = capture_param(path:) if key == ':'
+
+        current_node = current_node.upsert_child(key:)
+      end
+
+      raise DuplicatePathError, "Path already defined: #{line.path}" if current_node.line
+
+      current_node.line = line
+    end
+
+    def match(tokens:, current_node: @root_node, index: 0, offset: 0, params: {})
+      return [] if tokens.empty?
+
+      [
+        *match_static(tokens:, current_node:, index:, offset:, params:),
+        *match_dynamic(tokens:, current_node:, index:, offset:, params:)
+      ]
+    end
+
+    private
+
+    # Match an input character with the trie or mimic the space character between tokens in the trie.
+    def match_static(tokens:, current_node:, index:, offset:, params:)
+      child_node = current_node.child(key: tokens[index][offset] || ' ')
+      return [] unless child_node
+
+      next_index, next_offset = advance(tokens:, index:, offset:)
+      result = end_match(child_node:, tokens:, index: next_index, offset: next_offset, params:)
+
+      [*result, *match(tokens:, current_node: child_node, index: next_index, offset: next_offset, params:)]
+    end
+
+    # Dynamic path segment: capture the remainder of the current token.
+    def match_dynamic(tokens:, current_node:, index:, offset:, params:)
+      current_node.params.flat_map do |param|
+        child_node = current_node.child(key: param)
+        arg, next_index, next_offset = capture_arg(tokens:, index:, offset:)
+        next_params = params.merge(param.delete_prefix(':').to_sym => arg)
+
+        result = end_match(child_node:, tokens:, index: next_index, offset: next_offset, params: next_params)
+
+        [*result, *match(tokens:, current_node: child_node, index: next_index, offset: next_offset, params: next_params)]
+      end
+    end
+
+    # Match an end node.
+    # TODO: Match a mid node.
+    def end_match(child_node:, tokens:, index:, offset:, params:)
+      if child_node.line && tokens[index + 1].nil?
+        return [Result.new(line: child_node.line, params:)]
+      end
+
+      []
+    end
+
+    def capture_param(path:)
+      param = [':']
+
+      path[@current_index...path.length].chars.each do |char|
+        break if PARAM_DELIMITERS.include?(char)
+
+        @current_index += 1
+        param << char
+      end
+
+      param.join
+    end
+
+    def advance(tokens:, index:, offset:)
+      token = tokens[index]
+
+      offset < token.length ? [index, offset + 1] : [index + 1, 0]
+    end
+
+    def capture_arg(tokens:, index:, offset:)
+      token = tokens[index]
+
+      [token[offset..], index, token.length]
+    end
+  end
+end

data/lib/trie_node.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'line'
+
+module Trees
+  class TrieNode
+    include LowType
+    using LowType::Syntax
+
+    # TODO: Represent empty hash/array return value as {}/[] rather than Hash/Array (https://github.com/low-rb/low_type/issues/16)
+    type_reader nodes: Hash[String => TrieNode] | Hash
+    type_reader params: Array[String] | Array
+    type_accessor line: Line | nil
+
+    def initialize
+      @nodes = {}
+      @params = []
+      @line = nil
+    end
+
+    def child(key: String)
+      @nodes[key]
+    end
+
+    def upsert_child(key: String)
+      @params << key if key.start_with?(':')
+      @nodes[key] || @nodes[key] = TrieNode.new
+    end
+  end
+end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Trees
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: trees
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - maedi
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: low_type
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "A CLI framework where you write the literal terminal commands and \nTrees
   breaks them apart into a tree of options.\n"
 email:
@@ -17,7 +31,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/plugs.rb
+- lib/line.rb
+- lib/trees.rb
+- lib/trie.rb
+- lib/trie_node.rb
 - lib/version.rb
 homepage: https://github.com/raindeer-rb/trees
 licenses: []

data/lib/plugs.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Trees
-
-end