sandbox-ruby 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d6bebcc0f50a70a8e26b1bd19147fc07ca6c121c91fb2c063a5c47d705c5362b
+  data.tar.gz: 663bc2289826e5d691b87ae8f012df879833072e182f549ccec4cda0d8d5245d
+SHA512:
+  metadata.gz: cbae14a48949f52be3a306120859bd43e61958a2e5996720bc4828ed520b7617d72af6f184ad59b63aa4af50e9186a23303197bd79c4af0632401995eb5bdf6b
+  data.tar.gz: 47b0258491e02735a3062df7d61c566d4ec445585f46cef1c05e86a125ab27cdd50d7d7621291a06395169fb22b5454e538be642e9d3d0a080c979ce0547c048

data/lib/sandbox/command.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Sandbox
+  ##
+  # Command
+  class Command
+    attr_reader :completion_proc, :aliases, :params
+    attr_accessor :name, :description, :global
+
+    ##
+    # Creates a new command
+    def initialize(name, shell, context, block, **options)
+      @name = name.to_sym
+      @shell = shell
+      @context = context
+      @block = block
+      @description = options[:description]
+      @global = options[:global]
+      @aliases = options[:aliases]&.map(&:to_sym)
+
+      @params = {}
+      params = options[:params]
+      params&.each do |param|
+        param = param.strip
+        if param.start_with?('[') && param.end_with?(']')
+          @params[param] = false
+        elsif param.start_with?('<') && param.end_with?('>')
+          @params[param] = true
+        end
+      end
+
+      @completion_proc = nil
+    end
+
+    ##
+    # Executes the command
+    def exec(tokens)
+      mandatory = @params.count { |_, v| v }
+      if mandatory > (tokens.length - 1)
+        print_usage
+        return
+      end
+
+      @block&.call(tokens, @shell, @context, self)
+    end
+
+    ##
+    # Sets a block for the readline auto completion
+    def completion(&block)
+      @completion_proc = block
+    end
+
+    ##
+    # Returns true if the command is global
+    def global?
+      @global
+    end
+
+    ##
+    # Returns the string representation of the command
+    def to_s
+      @name.to_s
+    end
+
+    ##
+    # Returns true if the name matches the command name or alias
+    def match?(name)
+      name = name&.to_sym
+      @name == name || @aliases&.include?(name)
+    end
+
+    ##
+    # Prints command usage
+    def print_usage
+      @shell.print("Usage: #{@name} ")
+      @shell.puts(params.keys.join(' '))
+    end
+  end
+end

data/lib/sandbox/context.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Sandbox
+  ##
+  # Context
+  class Context
+    INVALID_CHARS = [
+      '/',
+      '.',
+      '\s'
+    ].freeze
+
+    attr_reader :contexts, :commands, :completion_proc
+    attr_accessor :name, :description
+
+    ##
+    # Creates a new context
+    def initialize(name, shell, **options)
+      @name = name.to_sym
+      @shell = shell
+      @description = options[:description]
+
+      @contexts = []
+      @commands = []
+      @completion_proc = nil
+    end
+
+    ##
+    # Adds a new context to the current context
+    def add_context(name, **options)
+      raise ContextError, "Context #{name} contains invalid characters" if invalid_chars?(name)
+
+      name = name.downcase.to_sym
+      raise ContextError, "Context #{name} already exists in context #{self}" if context?(name)
+      raise ContextError, "Command #{name} already exists in context #{self}" if command?(name)
+
+      @contexts << Context.new(name, @shell, **options)
+      @contexts.last
+    end
+
+    ##
+    # Removes a context from the current context
+    def remove_context(name)
+      name = name.downcase.to_sym
+      raise ContextError, "Context #{name} doesn't exists in context #{self}" unless context?(name)
+
+      @contexts.delete_if { |c| c.name == name }
+    end
+
+    ##
+    # Adds a command to the current context
+    def add_command(name, **options, &block)
+      raise ContextError, "Command #{name} contains invalid characters" if invalid_chars?(name)
+
+      name = name.downcase.to_sym
+      raise ContextError, "Context #{name} already exists in context #{self}" if context?(name)
+      raise ContextError, "Command #{name} already exists in context #{self}" if command?(name)
+
+      command = Command.new(name, @shell, self, block, **options)
+      @commands << command
+      command
+    end
+
+    ##
+    # Removes a command from the current context
+    def remove_command(name)
+      name = name.downcase.to_sym
+      raise ContextError, "Command #{name} doesn't exists in context #{self}" unless command?(name)
+
+      @commands.delete_if { |c| c.match?(name) }
+    end
+
+    ##
+    # Executes the command in the current context
+    def exec(shell, tokens)
+      path = tokens.first.split('/')
+      if path.empty?
+        shell.path.clear
+        return
+      end
+
+      path_prev = shell.path.clone
+      shell.path.clear if tokens.first.start_with?('/')
+      if path.length > 1
+        path[0..-2].each do |p|
+          if p == '..'
+            shell.path.pop
+            next
+          end
+
+          shell.path << p.to_sym unless p.empty?
+        end
+      end
+
+      if path.last == '..'
+        shell.path.pop
+        return
+      end
+
+      current = shell.root.context(*shell.path)
+      if current.nil?
+        shell.puts("Unrecognized command: #{tokens.first}")
+        shell.path = path_prev
+        return
+      end
+
+      current.contexts.each do |context|
+        next unless context.name.to_s == path.last
+
+        shell.path << context.name
+        return nil
+      end
+
+      commands = []
+      commands += current.commands
+      commands += shell.root.commands.select(&:global?)
+      commands.each do |command|
+        next unless command.match?(path.last)
+
+        command.exec(tokens)
+        shell.path = path_prev
+        return nil
+      end
+
+      shell.puts("Unrecognized command: #{tokens.first}")
+      shell.path = path_prev
+    end
+
+    ##
+    # Returns a context by the path
+    def context(*path)
+      return self if path.empty?
+
+      path.map!(&:downcase)
+      path.map!(&:to_sym)
+      context = nil
+      current = self
+      path.each do |p|
+        context = current.contexts.detect { |c| c.name == p }
+        break if context.nil?
+
+        current = context
+      end
+      context
+    end
+
+    ##
+    # Returns a command by the path
+    def command(*path)
+      return if path.empty?
+
+      context = context(*path[0..-2])
+      context.commands.detect { |c| c.match?(path.last) }
+    end
+
+    ##
+    # Returns the string representation of the context
+    def to_s
+      @name.to_s
+    end
+
+    private
+
+    ##
+    # Returns true if the context exists in the current context
+    def context?(name)
+      @contexts.any? { |c| c.name == name }
+    end
+
+    ##
+    # Returns true if the command exists in the current context
+    def command?(name)
+      @commands.any? { |c| c.match?(name) }
+    end
+
+    ##
+    # Returns true if the name contains invalid characters
+    def invalid_chars?(name)
+      name =~ /[#{INVALID_CHARS.join}]/
+    end
+  end
+
+  ##
+  # Context error
+  class ContextError < StandardError; end
+end

data/lib/sandbox/shell.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require 'readline'
+require 'shellwords'
+
+CONFIRM_LIST = %i[y n].freeze
+
+module Sandbox
+  ##
+  # Shell
+  class Shell
+    DEFAULT_PROMPT = '> '
+    DEFAULT_BANNER = 'Sandbox shell'
+
+    attr_reader :root
+    attr_accessor :prompt, :banner, :path
+
+    ##
+    # Creates a new shell
+    def initialize(
+      input = $stdin,
+      output = $stdout,
+      prompt: DEFAULT_PROMPT,
+      banner: DEFAULT_BANNER,
+      history: true,
+      builtin_help: true,
+      builtin_quit: true,
+      builtin_path: true
+    )
+      @input = input
+      @output = output
+      @history = history
+
+      @prompt = prompt
+      @banner = banner
+
+      @root = Context.new(:root, self)
+      @path = []
+      @running = false
+      @reading = false
+
+      add_command_help if builtin_help
+      add_command_quit if builtin_quit
+      add_command_path if builtin_path
+    end
+
+    ##
+    # Runs the shell
+    def run
+      puts(@banner)
+      Readline.completion_proc = proc { |line| completion_proc(line) }
+      @running = true
+      while @running
+        begin
+          line = readline("#{formatted_path}#{@prompt}", @history)
+          if line.nil?
+            puts
+            break
+          end
+
+          line.strip!
+          next if line.empty?
+
+          exec(line)
+        rescue ShellError => e
+          puts(e)
+          retry
+        rescue Interrupt
+          print("\e[0G\e[J")
+        end
+      end
+    end
+
+    ##
+    # Executes command
+    def exec(line)
+      tokens = split_tokens(line)
+      @root.context(*@path).exec(self, tokens)
+    end
+
+    ##
+    # Reads and returns a line
+    def readline(prompt, history)
+      @reading = true
+      line = Readline.readline(prompt, history)
+      Readline::HISTORY.pop if line&.strip&.empty?
+      Readline::HISTORY.pop if Readline::HISTORY.length >= 2 && Readline::HISTORY[-2] == line
+      @reading = false
+      line
+    end
+
+    ##
+    # Stops the shell
+    def stop
+      @running = false
+    end
+
+    ##
+    # Prints data
+    def print(data)
+      @output.print(data)
+    end
+
+    ##
+    # Prints data with a line at the end
+    def puts(data = '')
+      @output.print("\e[0G\e[J") if @reading
+      @output.puts(data)
+      Readline.refresh_line if @reading
+    end
+
+    ##
+    # Requests the confirmation
+    def confirm(prompt, default: :n)
+      list = CONFIRM_LIST.join('/')
+      raise ShellError, "Default should be #{list}" unless CONFIRM_LIST.include?(default)
+
+      prompt = "#{prompt} (#{list}) [#{default}] "
+      loop do
+        line = readline(prompt, @history)
+
+        if line.nil?
+          puts
+          return
+        end
+
+        line.strip!
+        line.downcase!
+        return default == CONFIRM_LIST.first if line.empty?
+
+        next unless CONFIRM_LIST.map(&:to_s).include?(line)
+
+        return line == CONFIRM_LIST.first.to_s
+      end
+    end
+
+    ##
+    # Returns the current formatted path
+    def formatted_path
+      "/#{@path.join('/')}"
+    end
+
+    ##
+    # Adds a new context to the root context
+    def add_context(name, **options)
+      @root.add_context(name, **options)
+    end
+
+    ##
+    # Removes a context from the root context
+    def remove_context(name)
+      @root.remove_context(name)
+    end
+
+    ##
+    # Adds a command to the root context
+    def add_command(name, **options, &block)
+      @root.add_command(name, **options, &block)
+    end
+    ##
+
+    # Removes a command from the root context
+    def remove_command(name)
+      @root.remove_command(name)
+    end
+
+    ##
+    # Returns a context by the path from the root context
+    def context(*path)
+      @root.context(*path)
+    end
+
+    ##
+    # Returns a command by the path from the root context
+    def command(*path)
+      @root.command(*path)
+    end
+
+    private
+
+    ##
+    # Returns an array of tokens from the line
+    def split_tokens(line)
+      tokens = line.shellsplit
+      tokens.first&.downcase!
+      tokens
+    rescue ArgumentError => e
+      raise ShellError, e
+    end
+
+    ##
+    # Readline completion proc
+    def completion_proc(line)
+      tokens = split_tokens(Readline.line_buffer)
+
+      context = @root.context(*@path)
+      commands = []
+      commands += context.contexts
+      commands += context.commands
+      commands += @root.commands.select(&:global?) unless @path.empty?
+
+      command = commands.detect { |c| c.instance_of?(Command) && c.match?(tokens.first) }
+      list = commands.map(&:name)
+      list = command.completion_proc&.call(line, tokens, self, context, command) unless command.nil?
+
+      list&.grep(/^#{Regexp.escape(line)}/)
+    end
+
+    # Built-in help command
+    def add_command_help
+      @root.add_command(
+        :help,
+        aliases: ['?'],
+        description: 'This help',
+        global: true
+      ) do |tokens, shell|
+        list = []
+        list += @root.commands.select(&:global?) unless @path.empty?
+        list += @root.context(*@path).commands
+        list.sort! { |a, b| a.name <=> b.name }
+        list = @root.context(*@path).contexts.sort { |a, b| a.name <=> b.name } + list
+
+        unless tokens[1].nil?
+          cmd = list.detect { |c| c.instance_of?(Command) && c.match?(tokens[1]) }
+          if cmd.nil?
+            shell.puts("Unknown command #{tokens[1]}")
+            next
+          end
+
+          shell.puts(cmd.description) unless cmd.description.nil?
+          shell.print(' ')
+          cmd.print_usage
+          next
+        end
+
+        list.each do |c|
+          if c.instance_of?(Context)
+            shell.puts(
+              format(
+                ' %<name>-25s %<description>s',
+                name: "[#{c.name}]",
+                description: c.description
+              )
+            )
+            next
+          end
+
+          shell.puts(
+            format(
+              ' %<name>-25s %<description>s',
+              name: "#{c.name} #{c.params.keys.join(' ')}",
+              description: c.description
+            )
+          )
+        end
+      end
+    end
+
+    # Built-in quit command
+    def add_command_quit
+      @root.add_command(
+        :quit,
+        aliases: [:exit],
+        description: 'Quit',
+        global: true
+      ) do |_tokens, shell|
+        shell.stop
+      end
+    end
+
+    # Built-in path command
+    def add_command_path
+      @root.add_command(
+        :path,
+        description: 'Show path',
+        global: true
+      ) do |_tokens, shell|
+        shell.puts(shell.formatted_path)
+      end
+    end
+  end
+
+  ##
+  # Shell error
+  class ShellError < StandardError; end
+end

data/lib/sandbox/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sandbox
+  VERSION = '0.1'
+end

data/lib/sandbox.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'sandbox/version'
+require 'sandbox/shell'
+require 'sandbox/context'
+require 'sandbox/command'

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: sandbox-ruby
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- anim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-05-12 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: me@telpart.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sandbox.rb
+- lib/sandbox/command.rb
+- lib/sandbox/context.rb
+- lib/sandbox/shell.rb
+- lib/sandbox/version.rb
+homepage: https://github.com/animotto/sandbox-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Sandbox shell library for Ruby
+test_files: []