ronin-core 0.1.0.beta1

data/lib/ronin/core/params/types.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2021-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-core is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ronin-core 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 Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-core.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/core/params/exceptions'
+require 'ronin/core/params/types/string'
+require 'ronin/core/params/types/boolean'
+require 'ronin/core/params/types/integer'
+require 'ronin/core/params/types/float'
+require 'ronin/core/params/types/regexp'
+require 'ronin/core/params/types/uri'
+require 'ronin/core/params/types/enum'
+
+module Ronin
+  module Core
+    module Params
+      module Types
+        # Mapping of ruby core classes to param types.
+        TYPE_ALIASES = {
+          ::String  => Types::String,
+          ::Integer => Types::Integer,
+          ::Float   => Types::Float,
+          ::Regexp  => Types::Regexp,
+          ::URI     => Types::URI,
+        }
+
+        #
+        # Looks up a type class.
+        #
+        # @param [Class] type_class
+        #   The ruby class to map to a param type class.
+        #
+        # @return [Class<Types::Type>]
+        #   The param type class.
+        #
+        def self.lookup(type_class)
+          if type_class < Type
+            type_class
+          else
+            TYPE_ALIASES.fetch(type_class) do
+              raise(UnknownType,"unknown param type: #{type_class.inspect}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ronin/core/params.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2021-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-core is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ronin-core 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 Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-core.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/core/params/mixin'

data/lib/ronin/core/version.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2021-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-core is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ronin-core 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 Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-core.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+module Ronin
+  module Core
+    # ronin-core version
+    VERSION = '0.1.0.beta1'
+  end
+end

data/ronin-core.gemspec

@@ -0,0 +1,59 @@
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'ronin/core/version'
+                  Ronin::Core::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+  gem.metadata    = gemspec['metadata'] if gemspec['metadata']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files  = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+  gem.files += Array(gemspec['generated_files'])
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || 'spec/{**/}*_spec.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/spec/class_registry_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+require 'ronin/core/class_registry'
+
+require 'fixtures/example_class_registry'
+
+describe Ronin::Core::ClassRegistry do
+  let(:fixtures_dir) { File.join(__dir__,'fixtures') }
+
+  describe ".class_dir" do
+    context "when a class_dir has been defined" do
+      module TestClassRegistry
+        module WithAModulesDir
+          include Ronin::Core::ClassRegistry
+
+          class_dir "#{__dir__}/test/dir"
+        end
+      end
+
+      subject { TestClassRegistry::WithAModulesDir }
+
+      it "must return the previously set .class_dir" do
+        expect(subject.class_dir).to eq("#{__dir__}/test/dir")
+      end
+    end
+
+    context "but when no class_dir has been defined" do
+      module TestClassRegistry
+        module WithNoModuleLoadPath
+          include Ronin::Core::ClassRegistry
+        end
+      end
+
+      subject { TestClassRegistry::WithNoModuleLoadPath }
+
+      it do
+        expect {
+          subject.class_dir
+        }.to raise_error(NotImplementedError,"#{subject} did not define a class_dir")
+      end
+    end
+  end
+
+  subject { ExampleClassRegistry }
+
+  describe ".list_files" do
+    it "must return an Array of module names" do
+      expect(subject.list_files).to eq(
+        %w[
+          loaded_class
+          name_mismatch
+          no_module
+        ]
+      )
+    end
+  end
+
+  describe ".registry" do
+    it "must default to {}" do
+      expect(subject.registry).to eq({})
+    end
+  end
+
+  describe ".path_for" do
+    context "when the module name exists within the .class_dir" do
+      let(:id) { 'loaded_class' }
+
+      it "must return the path to the .rb file for the module" do
+        expect(subject.path_for(id)).to eq(
+          File.join(subject.class_dir,"#{id}.rb")
+        )
+      end
+    end
+
+    context "when the module name does not have a file within .class_dir" do
+      let(:id) { "does_not_exist" }
+
+      it "must return nil" do
+        expect(subject.path_for(id)).to be(nil)
+      end
+    end
+  end
+
+  describe ".register" do
+    module TestClassRegistry
+      module ExampleNamespace
+        class Foo
+        end
+      end
+    end
+
+    let(:id)    { 'foo' }
+    let(:klass) { TestClassRegistry::ExampleNamespace::Foo }
+
+    before { subject.register(id,klass) }
+
+    it "must add the class id and class to #registry" do
+      expect(subject.registry[id]).to be(klass)
+    end
+
+    after { subject.registry.clear }
+  end
+
+  describe ".load_class_from_file" do
+    let(:id)    { 'loaded_class' }
+    let(:file)  { File.join(subject.class_dir,"#{id}.rb") }
+    let(:klass) { ExampleClassRegistry::LoadedClass }
+
+    it "must require the file" do
+      subject.load_class_from_file(file)
+
+      expect($LOADED_FEATURES).to include(file)
+    end
+
+    it "must return the registered module" do
+      expect(subject.load_class_from_file(file)).to be(klass)
+    end
+
+    it "must register the module with the same id as the file" do
+      subject.load_class_from_file(file)
+
+      expect(subject.registry[id]).to be(klass)
+    end
+
+    context "when given a relative path" do
+      let(:relative_path) { File.join(subject.class_dir,'foo','..',"#{id}.rb") }
+      let(:absolute_path) { File.expand_path(relative_path) }
+
+      it "must expand the path first" do
+        expect(subject).to receive(:require).with(absolute_path) do
+          load(absolute_path)
+        end
+
+        subject.load_class_from_file(relative_path)
+      end
+    end
+
+    context "when the file does not exist" do
+      let(:file)          { "path/does/not/exist.rb" }
+      let(:absolute_path) { File.expand_path(file)   }
+
+      it do
+        expect {
+          subject.load_class_from_file(file)
+        }.to raise_error(described_class::ClassNotFound,"no such file or directory: #{absolute_path.inspect}")
+      end
+    end
+
+    context "when the file does not register a module" do
+      let(:id)   { 'no_module' }
+      let(:file) { File.join(subject.class_dir,"#{id}.rb") }
+
+      it do
+        expect {
+          subject.load_class_from_file(file)
+        }.to raise_error(described_class::ClassNotFound,"file did not register a class: #{file.inspect}")
+      end
+    end
+
+    after do
+      subject.registry.clear
+      $LOADED_FEATURES.delete(file)
+    end
+  end
+
+  describe ".load_class" do
+    let(:id)    { 'loaded_class' }
+    let(:klass) { ExampleClassRegistry::LoadedClass }
+    let(:path)  { File.join(subject.class_dir,"#{id}.rb") }
+
+    it "must require the file within the .class_dir" do
+      subject.load_class(id)
+
+      expect($LOADED_FEATURES).to include(path)
+    end
+
+    it "must return the registered module" do
+      expect(subject.load_class(id)).to be(klass)
+    end
+
+    it "must register the module with the same id as the file" do
+      subject.load_class(id)
+
+      expect(subject.registry[id]).to be(klass)
+    end
+
+    context "when the file does not exist" do
+      let(:id) { 'does_not_exist' }
+
+      it do
+        expect {
+          subject.load_class(id)
+        }.to raise_error(described_class::ClassNotFound,"could not find file for #{id.inspect}")
+      end
+    end
+
+    context "when the file does not register a module" do
+      let(:id)   { 'no_module' }
+
+      it do
+        expect {
+          subject.load_class(id)
+        }.to raise_error(described_class::ClassNotFound,"file did not register a class: #{path.inspect}")
+      end
+    end
+
+    context "when the file registers a module of a different name" do
+      let(:id)            { 'name_mismatch' }
+      let(:unexpected_id) { 'different_name' }
+
+      it do
+        expect {
+          subject.load_class(id)
+        }.to raise_error(described_class::ClassNotFound,"file registered a class with a different id (#{unexpected_id.inspect}): #{path.inspect}")
+      end
+
+      
+    end
+
+    after do
+      subject.registry.clear
+      $LOADED_FEATURES.delete(path)
+    end
+  end
+end

data/spec/cli/command_shell/command_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'ronin/core/cli/command_shell/command'
+
+describe Ronin::Core::CLI::CommandShell::Command do
+  let(:name)        { :foo }
+  let(:usage)       { 'ARG1 [ARG2]' }
+  let(:completions) { %w[arg1 arg2] }
+  let(:summary)     { 'Foo bar baz' }
+  let(:help) do
+    [
+      "Foo bar baz",
+      "blah blah blah",
+      "",
+      "  foo /bar",
+      ""
+    ].join($/)
+  end
+
+  subject do
+    described_class.new(name, usage:       usage,
+                              completions: completions,
+                              summary:     summary,
+                              help:        help)
+  end
+
+  describe "#initialize" do
+    subject { described_class.new(name, summary: summary) }
+
+    it "must set #name" do
+      expect(subject.name).to eq(name)
+    end
+
+    it "must default #method_name to name" do
+      expect(subject.method_name).to eq(name)
+    end
+
+    it "must default #usage to nil" do
+      expect(subject.usage).to be(nil)
+    end
+
+    it "must default #completions to nil" do
+      expect(subject.completions).to be(nil)
+    end
+
+    it "must default #help to #summary" do
+      expect(subject.help).to eq(subject.summary)
+    end
+
+    context "when the method_name: keyword is given" do
+      let(:method_name) { 'foo2' }
+
+      subject do
+        described_class.new(name, method_name: method_name,
+                                  summary:     summary)
+      end
+
+      it "must override #method_name" do
+        expect(subject.method_name).to eq(method_name)
+      end
+    end
+
+    context "when the usage: keyword is given" do
+      subject do
+        described_class.new(name, usage:   usage,
+                                  summary: summary)
+      end
+
+      it "must set #usage" do
+        expect(subject.usage).to eq(usage)
+      end
+    end
+
+    context "when the completions: keyword is given" do
+      subject do
+        described_class.new(name, usage:       usage,
+                                  summary:     summary,
+                                  completions: completions)
+      end
+
+      it "must set #completions" do
+        expect(subject.completions).to eq(completions)
+      end
+    end
+
+    context "when the help: keyword is given" do
+      subject do
+        described_class.new(name, usage:   usage,
+                                  summary: summary,
+                                  help:    help)
+      end
+
+      it "must set #help" do
+        expect(subject.help).to eq(help)
+      end
+    end
+  end
+
+  describe "#to_s" do
+    context "when #usage is set" do
+      it "must return the #name and #usage string" do
+        expect(subject.to_s).to eq("#{name} #{usage}")
+      end
+    end
+
+    context "when #usage is not set" do
+      subject { described_class.new(name, summary: summary) }
+
+      it "must return the #name as a String" do
+        expect(subject.to_s).to eq(name.to_s)
+      end
+    end
+  end
+end