ronin-repos 0.1.0.beta1

data/man/ronin-repos.1.md

@@ -0,0 +1,37 @@
+# ronin-repos 1 "2022-01-01" Ronin Repos "User Manuals"
+
+## SYNOPSIS
+
+`ronin-repos` [*options*] [*COMMAND*]
+
+## DESCRIPTION
+
+Allows downloading and managing git repositories. `ronin-repos` can install
+and use any git repository containing Ruby code or other data.
+
+## OPTIONS
+
+`-h`, `--help`
+  Prints help information.
+
+## FILES
+
+*~/.cache/ronin-repos*
+	Installation directory for repositories.
+
+## ENVIRONMENT
+
+HOME
+	Specifies the home directory of the user. Ronin will search for the
+	*~/.cache/ronin-repos* cache directory within the home directory.
+
+XDG_CACHE_HOME
+  Specifies the cache directory to use. Defaults to *$HOME/.cache*.
+
+## AUTHOR
+
+Postmodern <postmodern.mod3@gmail.com>
+
+## SEE ALSO
+
+ronin-repos-install(1) ronin-repos-list(1) ronin-repos-remove(1) ronin-repos-update(1) ronin-repos-purge(1)

data/ronin-repos.gemspec

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+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/repos/version'
+                  Ronin::Repos::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.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  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/cache_dir_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+require 'ronin/repos/cache_dir'
+
+describe Ronin::Repos::CacheDir do
+  let(:fixtures_dir) { File.expand_path(File.join(__dir__,'fixtures')) }
+  let(:cache_dir)    { File.join(fixtures_dir,'cache') }
+
+  describe "PATH" do
+    subject { described_class::PATH }
+
+    it "must default to ~/.cache/ronin-repos" do
+      expect(subject).to eq(File.join(ENV['HOME'],'.cache','ronin-repos'))
+    end
+  end
+
+  subject { described_class.new(cache_dir) }
+
+  describe "#initialize" do
+    context "when no arguments are given" do
+      subject { described_class.new }
+
+      it "must set #path to PATH" do
+        expect(subject.path).to eq(described_class::PATH)
+      end
+    end
+
+    context "when given a path argument" do
+      subject { described_class.new(cache_dir) }
+
+      it "must set #path" do
+        expect(subject.path).to eq(cache_dir)
+      end
+    end
+  end
+
+  describe "#[]" do
+    context "when a repository with the given name exists in the cache dir" do
+      let(:name) { 'repo2' }
+
+      it "must return a Repository object with the matching name" do
+        repo = subject[name]
+
+        expect(repo).to be_kind_of(Repository)
+        expect(repo.name).to eq(name)
+      end
+    end
+
+    context "when given an unknown repository name" do
+      let(:name) { 'does_not_exist' }
+
+      it do
+        expect {
+          subject[name]
+        }.to raise_error(RepositoryNotFound,"repository not found: #{name.inspect}")
+      end
+    end
+  end
+
+  describe "#each" do
+    context "when given a block" do
+      it "must yield each Repository object" do
+        yielded_repos = []
+
+        subject.each do |repo|
+          yielded_repos << repo
+        end
+
+        expect(yielded_repos.length).to eq(2)
+        expect(yielded_repos[0]).to be_kind_of(Repository)
+        expect(yielded_repos[0].name).to eq("repo1")
+
+        expect(yielded_repos[1]).to be_kind_of(Repository)
+        expect(yielded_repos[1].name).to eq("repo2")
+      end
+
+      context "when #path does not exist" do
+        subject { described_class.new('/does/not/exist') }
+
+        it "must not yield anything" do
+          expect { |b|
+            subject.each(&b)
+          }.to_not yield_control
+        end
+      end
+    end
+
+    context "when no block is given" do
+      it "must return an Enumerator object" do
+        yielded_repos = subject.each.to_a
+
+        expect(yielded_repos.length).to eq(2)
+        expect(yielded_repos[0]).to be_kind_of(Repository)
+        expect(yielded_repos[0].name).to eq("repo1")
+
+        expect(yielded_repos[1]).to be_kind_of(Repository)
+        expect(yielded_repos[1].name).to eq("repo2")
+      end
+
+      context "when #path does not exist" do
+        subject { described_class.new('/does/not/exist') }
+
+        it "the Enumerator must not return anything" do
+          expect(subject.each.to_a).to be_empty
+        end
+      end
+    end
+  end
+
+  describe "#install" do
+    let(:name) { 'new_repo' }
+    let(:uri)  { "https://github.com/example/#{name}.git" }
+    let(:path) { File.join(cache_dir,name) }
+
+    let(:new_repo) { double('Repository') }
+
+    it "must `git clone` the given URI into the cache directory" do
+      expect(Repository).to receive(:system).with(
+        'git', 'clone', uri, path
+      ).and_return(true)
+
+      expect(Repository).to receive(:new).and_return(new_repo)
+
+      expect(subject.install(uri)).to be(new_repo)
+    end
+
+    context "when a custom name is given" do
+      let(:custom_name) { 'custom-repo' }
+      let(:path)        { File.join(cache_dir,custom_name) }
+
+      it "must use the custom name instead of deriving the repository's name" do
+        expect(Repository).to receive(:system).with(
+          'git', 'clone', uri, path
+        ).and_return(true)
+
+        expect(Repository).to receive(:new).and_return(new_repo)
+
+        expect(subject.install(uri,custom_name)).to be(new_repo)
+      end
+    end
+  end
+
+  describe "#update" do
+    it "must call #update on each repository in the cache directory"
+
+    context "but system() returns nil" do
+      it do
+        expect_any_instance_of(Repository).to receive(:system).and_return(nil)
+
+        expect {
+          subject.update
+        }.to raise_error(CommandNotInstalled,"git is not installed")
+      end
+    end
+  end
+
+  describe "#remove" do
+    let(:name) { 'repo2' }
+
+    it "must call #delete on the Repository" do
+      expect_any_instance_of(Repository).to receive(:delete)
+
+      subject.remove(name)
+    end
+
+    context "when given an unknown repository name" do
+      let(:name) { 'does-not-exist' }
+
+      it do
+        expect {
+          subject.remove(name)
+        }.to raise_error(RepositoryNotFound,"repository not found: #{name.inspect}")
+      end
+    end
+  end
+
+  describe "#purge" do
+    it "must call #delete on every repository in the cache directory" do
+      expect(FileUtils).to receive(:rm_rf).with(File.join(cache_dir,'repo1'))
+      expect(FileUtils).to receive(:rm_rf).with(File.join(cache_dir,'repo2'))
+
+      subject.purge
+    end
+  end
+
+  describe "#find_file" do
+    let(:relative_path) { 'only-exists-in-repo2.txt' }
+
+    it "must return the first file that matches the given relative path" do
+      expect(subject.find_file(relative_path)).to eq(
+        File.join(cache_dir,'repo2',relative_path)
+      )
+    end
+
+    context "when the relative path does not exist within any repository" do
+      let(:relative_path) { 'does/not/exist.txt' }
+
+      it "must return nil" do
+        expect(subject.find_file(relative_path)).to be(nil)
+      end
+    end
+  end
+
+  describe "#glob" do
+    context "when the pattern matches files within all repositories" do
+      let(:pattern) { 'dir/*.txt' }
+
+      let(:expected_paths) do
+        Dir[File.join(cache_dir,'*',pattern)]
+      end
+
+      it "must return the absolute paths that matches the pattern, in order" do
+        expect(subject.glob(pattern)).to eq(expected_paths.sort)
+      end
+
+      context "when a block is given" do
+        it "must yield the matching absolute paths" do
+          expect { |b|
+            subject.glob(pattern,&b)
+          }.to yield_successive_args(*expected_paths.sort)
+        end
+      end
+    end
+
+    context "when the relative path does not exist within any repository" do
+      let(:pattern) { 'does/not/exist/*.txt' }
+
+      it "must return []" do
+        expect(subject.glob(pattern)).to eq([])
+      end
+
+      context "when a block is given" do
+        it "must not yield" do
+          expect { |b|
+            subject.glob(pattern,&b)
+          }.to_not yield_control
+        end
+      end
+    end
+  end
+
+  describe "#list_files" do
+    context "when given no arguments" do
+      it "must list every unique file within each repository" do
+        expect(subject.list_files).to eq(
+          Set.new(
+            %w[
+              dir/file1.txt
+              dir/file2.txt
+              file1.txt
+              file2.txt
+              only-exists-in-repo2.txt
+            ]
+          )
+        )
+      end
+    end
+
+    context "when given a glob pattern" do
+      it "must list only the files that match the glob pattern" do
+        expect(subject.list_files('dir/*.txt')).to eq(
+          Set.new(%w[dir/file1.txt dir/file2.txt])
+        )
+      end
+    end
+  end
+
+  describe "#to_s" do
+    it "must return the cache directory path" do
+      expect(subject.to_s).to eq(cache_dir)
+    end
+  end
+end

data/spec/class_dir_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'ronin/repos/class_dir'
+
+describe Ronin::Repos::ClassDir do
+  let(:fixtures_dir) { File.expand_path(File.join(__dir__,'fixtures')) }
+
+  describe ".repo_class_dir" do
+    context "when a repo_class_dir has been defined" do
+      module TestClassDir
+        module WithReposClassDirSet
+          include Ronin::Repos::ClassDir
+
+          repo_class_dir "dir"
+        end
+      end
+
+      subject { TestClassDir::WithReposClassDirSet }
+
+      it "must return the previously set .repo_class_dir" do
+        expect(subject.repo_class_dir).to eq("dir")
+      end
+    end
+
+    context "but when no repo_class_dir has been defined" do
+      module TestReposDir
+        module WithoutReposDirSet
+          include Ronin::Repos::ClassDir
+        end
+      end
+
+      subject { TestReposDir::WithoutReposDirSet }
+
+      it do
+        expect {
+          subject.repo_class_dir
+        }.to raise_error(NotImplementedError,"#{subject} did not define a repo_class_dir")
+      end
+    end
+  end
+
+  module TestReposDir
+    module ExampleNamespace
+      include Ronin::Core::ClassRegistry
+      include Ronin::Repos::ClassDir
+
+      class_dir "#{__dir__}/fixtures/class_dir"
+      repo_class_dir 'dir'
+    end
+  end
+
+  subject { TestReposDir::ExampleNamespace }
+
+  describe ".list_files" do
+    before do
+      expect(Ronin::Repos).to receive(:list_files).and_return(
+        Set.new(
+          %w[
+            file1.rb
+            file2.rb
+          ]
+        )
+      )
+    end
+
+    it "must list the modules in the .class_dir and in all .repo_class_dir" do
+      expect(subject.list_files).to eq(
+        %w[
+          file1
+          file2
+          only_in_class_dir
+        ]
+      )
+    end
+  end
+
+  describe ".path_for" do
+    context "when the module name exists in the .class_dir" do
+      it "must return the path to the module file in .class_dir" do
+        expect(subject.path_for('only_in_class_dir')).to eq(
+          File.join(subject.class_dir,'only_in_class_dir.rb')
+        )
+      end
+    end
+
+    context "when the module name exists in one of the installed repos" do
+      it "must call Repos.find_file with the .repo_class_dir and module file name" do
+        expect(Ronin::Repos).to receive(:find_file).with(
+          File.join(subject.repo_class_dir,'file.rb')
+        ).and_return("/path/to/#{subject.repo_class_dir}/file.rb")
+
+        expect(subject.path_for('file')).to eq(
+          "/path/to/#{subject.repo_class_dir}/file.rb"
+        )
+      end
+    end
+  end
+end

data/spec/repos_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'ronin/repos'
+
+describe Ronin::Repos do
+  it "should have a version" do
+    expect(subject.const_defined?('VERSION')).to be(true)
+  end
+
+  let(:cache_dir) { described_class.class_variable_get('@@cache_dir') }
+
+  describe "@@cache_dir" do
+    subject { cache_dir }
+
+    it "must be a CacheDir pointing to ~/.cache/ronin-repos" do
+      expect(subject).to be_kind_of(CacheDir)
+      expect(subject.path).to eq(File.expand_path("~/.cache/ronin-repos"))
+    end
+  end
+
+  describe ".find_file" do
+    let(:relative_path) { 'file.txt' }
+    let(:matches) do
+      [
+        "/path/to/repo1/file.txt",
+        "/path/to/repo2/file.txt"
+      ]
+    end
+
+    it "must call @@cache_dir.find_file" do
+      expect(cache_dir).to receive(:find_file).with(relative_path).and_return(matches)
+
+      expect(subject.find_file(relative_path)).to be(matches)
+    end
+  end
+
+  describe ".glob" do
+    let(:pattern) { 'dir/*.txt' }
+    let(:matches) do
+      [
+        "/path/to/repo1/dir/file.txt",
+        "/path/to/repo2/dir/file.txt"
+      ]
+    end
+
+    it "must call @@cache_dir.glob" do
+      expect(cache_dir).to receive(:glob).with(pattern).and_return(matches)
+
+      expect(subject.glob(pattern)).to be(matches)
+    end
+  end
+
+  describe ".list_files" do
+    let(:pattern) { 'dir/*.txt' }
+    let(:files) do
+      Set[
+        "dir/file.txt",
+        "dir/file.txt"
+      ]
+    end
+
+    it "must call @@cache_dir.list_files" do
+      expect(cache_dir).to receive(:list_files).with(pattern).and_return(files)
+
+      expect(subject.list_files(pattern)).to be(files)
+    end
+  end
+end